LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::voronoicell_base()
voronoicell_base::voronoicell_base() :
    current_vertices(init_vertices), current_vertex_order(init_vertex_order),
    current_delete_size(init_delete_size), current_delete2_size(init_delete2_size),
    ed(new int*[current_vertices]), nu(new int[current_vertices]),
    pts(new double[3*current_vertices]), mem(new int[current_vertex_order]),
    mec(new int[current_vertex_order]), mep(new int*[current_vertex_order]),
    ds(new int[current_delete_size]), stacke(ds+current_delete_size),
    ds2(new int[current_delete2_size]), stacke2(ds2+current_delete_size),
    current_marginal(init_marginal), marg(new int[current_marginal]) {
    int i;
    for(i=0;i<3;i++) {
        mem[i]=init_n_vertices;mec[i]=0;
        mep[i]=new int[init_n_vertices*((i<<1)+1)];
    }
    mem[3]=init_3_vertices;mec[3]=0;
    mep[3]=new int[init_3_vertices*7];
    for(i=4;i<current_vertex_order;i++) {
        mem[i]=init_n_vertices;mec[i]=0;
        mep[i]=new int[init_n_vertices*((i<<1)+1)];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4633e(%rip), %rax     # 0x61c98
movq %rax, (%rdi)
movaps 0x33c3c(%rip), %xmm0    # 0x4f5a0
movups %xmm0, 0x8(%rdi)
movl $0x800, %edi            # imm = 0x800
callq 0x7030
movq %rax, 0x20(%rbx)
movl $0x400, %r14d           # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x7030
movq %rax, 0x28(%rbx)
movl $0x1800, %edi           # imm = 0x1800
callq 0x7030
movq %rax, 0x30(%rbx)
movl $0x100, %edi            # imm = 0x100
callq 0x7030
movq %rax, 0x38(%rbx)
movl $0x100, %edi            # imm = 0x100
callq 0x7030
movq %rax, 0x40(%rbx)
movl $0x200, %edi            # imm = 0x200
callq 0x7030
movq %rax, 0x48(%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0x7030
movq %rax, 0x50(%rbx)
addq %r14, %rax
movq %rax, 0x58(%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0x7030
movq %rax, 0x60(%rbx)
addq %r14, %rax
movq %rax, 0x68(%rbx)
movl $0x40, 0x70(%rbx)
movl $0x100, %edi            # imm = 0x100
callq 0x7030
movq %rax, 0x78(%rbx)
movl $0x20, %r14d
xorl %r15d, %r15d
movq 0x38(%rbx), %rax
movl $0x8, (%rax,%r15,4)
movq 0x40(%rbx), %rax
movl $0x0, (%rax,%r15,4)
movq %r14, %rdi
callq 0x7030
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
addq $0x40, %r14
cmpq $0x3, %r15
jne 0x1ba0a
movq 0x38(%rbx), %rax
movl $0x100, 0xc(%rax)       # imm = 0x100
movq 0x40(%rbx), %rax
movl $0x0, 0xc(%rax)
movl $0x1c00, %edi           # imm = 0x1C00
callq 0x7030
movq 0x48(%rbx), %rcx
movq %rax, 0x18(%rcx)
cmpl $0x5, 0xc(%rbx)
jl 0x1bac7
movl $0x4, %r14d
movl $0x40, %r15d
movq $-0x1, %r12
movq 0x38(%rbx), %rax
movl $0x8, (%rax,%r14,4)
movq 0x40(%rbx), %rax
movl $0x0, (%rax,%r14,4)
leal 0x8(%r15), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
testl %r15d, %r15d
cmovsq %r12, %rdi
callq 0x7030
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
movslq 0xc(%rbx), %rax
addl $0x10, %r15d
cmpq %rax, %r14
jl 0x1ba80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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 [] marg;
    delete [] ds2;delete [] ds;
    delete [] mep;delete [] mec;
    delete [] mem;delete [] pts;
    delete [] nu;delete [] ed;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x461b6(%rip), %rax     # 0x61c98
movq %rax, (%rdi)
movslq 0xc(%rdi), %r14
testq %r14, %r14
jle 0x1bb19
incq %r14
movq 0x38(%rbx), %rax
cmpl $0x0, -0x8(%rax,%r14,4)
jle 0x1bb10
movq 0x48(%rbx), %rax
movq -0x10(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1bb10
callq 0x7480
decq %r14
cmpq $0x1, %r14
jg 0x1baf1
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb27
callq 0x7480
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb35
callq 0x7480
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb43
callq 0x7480
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb51
callq 0x7480
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb5f
callq 0x7480
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb6d
callq 0x7480
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb7b
callq 0x7480
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb89
callq 0x7480
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x1bb9e
popq %rbx
popq %r14
jmp 0x7480
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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<3*p;i++) pts[i]=vb->pts[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rdi)
movl $0x0, 0x1c(%rdi)
cmpl $0x0, 0xc(%rdi)
jle 0x1bc85
movl $0x1, %eax
movl $0x4, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
movq 0x40(%rsi), %r9
movl (%r9,%r8,4), %r11d
movq 0x40(%rdi), %r10
movl %r11d, (%r10,%r8,4)
leaq 0x1(,%r8,2), %r9
movl %r9d, %ebx
imull %r11d, %ebx
testl %ebx, %ebx
jle 0x1bc21
movq 0x48(%rsi), %r11
movq (%r11,%r8,8), %r11
movq 0x48(%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 0x1bc09
movq 0x40(%rdi), %r10
movl (%r10,%r8,4), %r10d
imull %r9d, %r10d
testl %r10d, %r10d
jle 0x1bc69
movslq %r9d, %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
movq 0x20(%rdi), %rbx
movq 0x48(%rdi), %r14
movq (%r14,%r8,8), %r14
addq %r10, %r14
movslq (%rdx,%r14), %r15
movq %r14, (%rbx,%r15,8)
addq %rax, %r11
movq 0x40(%rdi), %rbx
movslq (%rbx,%r8,4), %rbx
imulq %r9, %rbx
addq %rcx, %r10
cmpq %rbx, %r11
jl 0x1bc3b
incq %r8
movslq 0xc(%rdi), %r9
addq $0x2, %rax
addq $0x8, %rdx
addq $0x8, %rcx
cmpq %r9, %r8
jl 0x1bbd0
movl 0x18(%rdi), %eax
testl %eax, %eax
jle 0x1bcab
movq 0x28(%rsi), %rcx
movq 0x28(%rdi), %rdx
xorl %r8d, %r8d
movl (%rcx,%r8,4), %eax
movl %eax, (%rdx,%r8,4)
incq %r8
movslq 0x18(%rdi), %rax
cmpq %rax, %r8
jl 0x1bc97
testl %eax, %eax
jle 0x1bcdc
leal (%rax,%rax,2), %r8d
movq 0x30(%rsi), %rax
movq 0x30(%rdi), %rcx
cmpl $0x2, %r8d
movl $0x1, %edx
cmovgel %r8d, %edx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x1bcca
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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+3*p) {
        *(ptsp++)=x;*(ptsp++)=y;*(ptsp++)=z;
    }
}

// Assembly:
movslq 0x18(%rdi), %rcx
testq %rcx, %rcx
jle 0x1bef0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm1
addsd %xmm2, %xmm2
movq 0x30(%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
movsd %xmm2, 0x10(%rax)
addq $0x18, %rax
cmpq %rcx, %rax
jb 0x1bed9
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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[3]=l;pts[4]=0;pts[5]=0;
    pts[6]=0;pts[7]=-l;pts[8]=0;
    pts[9]=0;pts[10]=l;pts[11]=0;
    pts[12]=0;pts[13]=0;pts[14]=-l;
    pts[15]=0;pts[16]=0;pts[17]=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 0x1c129
movq 0x40(%rdi), %rax
xorl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
incq %rcx
movslq 0xc(%rdi), %rdx
cmpq %rdx, %rcx
jl 0x1c116
movq $0x6, 0x18(%rdi)
movq 0x40(%rdi), %rax
movl $0x6, 0x10(%rax)
addsd %xmm0, %xmm0
movapd 0x2ea18(%rip), %xmm1    # 0x4ab60
xorpd %xmm0, %xmm1
movq 0x30(%rdi), %rax
movlpd %xmm1, (%rax)
xorps %xmm2, %xmm2
movups %xmm2, 0x8(%rax)
movsd %xmm0, 0x18(%rax)
movups %xmm2, 0x20(%rax)
xorl %ecx, %ecx
movq %rcx, 0x30(%rax)
movlpd %xmm1, 0x38(%rax)
movups %xmm2, 0x40(%rax)
movsd %xmm0, 0x50(%rax)
movups %xmm2, 0x58(%rax)
movq %rcx, 0x68(%rax)
movlpd %xmm1, 0x70(%rax)
movups %xmm2, 0x78(%rax)
movsd %xmm0, 0x88(%rax)
movq 0x48(%rdi), %rax
movq 0x20(%rax), %rax
movaps 0x33500(%rip), %xmm0    # 0x4f6a0
movups %xmm0, (%rax)
leaq 0x24(%rax), %rcx
movups %xmm2, 0x10(%rax)
movl $0x0, 0x20(%rax)
movaps 0x334f7(%rip), %xmm0    # 0x4f6b0
movups %xmm0, 0x24(%rax)
movaps 0x334fc(%rip), %xmm0    # 0x4f6c0
movups %xmm0, 0x34(%rax)
movaps 0x33501(%rip), %xmm0    # 0x4f6d0
movups %xmm0, 0x44(%rax)
leaq 0x48(%rax), %rdx
movaps 0x33502(%rip), %xmm0    # 0x4f6e0
movups %xmm0, 0x54(%rax)
movaps 0x33507(%rip), %xmm0    # 0x4f6f0
movups %xmm0, 0x64(%rax)
leaq 0x6c(%rax), %rsi
movaps 0x33508(%rip), %xmm0    # 0x4f700
movups %xmm0, 0x74(%rax)
movaps 0x3350d(%rip), %xmm0    # 0x4f710
movups %xmm0, 0x84(%rax)
leaq 0x90(%rax), %r8
movaps 0x33508(%rip), %xmm0    # 0x4f720
movups %xmm0, 0x94(%rax)
movaps 0x3350a(%rip), %xmm0    # 0x4f730
movups %xmm0, 0xa4(%rax)
leaq 0xb4(%rax), %r9
movaps 0x33505(%rip), %xmm0    # 0x4f740
movups %xmm0, 0xb4(%rax)
movaps 0x33507(%rip), %xmm0    # 0x4f750
movups %xmm0, 0xc4(%rax)
movl $0x5, 0xd4(%rax)
movq 0x20(%rdi), %r10
movq %rax, (%r10)
movq 0x20(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rdi), %rax
movq %rdx, 0x10(%rax)
movq 0x20(%rdi), %rax
movq %rsi, 0x18(%rax)
movq 0x20(%rdi), %rax
movq %r8, 0x20(%rax)
movq 0x20(%rdi), %rax
movq %r9, 0x28(%rax)
movq 0x28(%rdi), %rax
movabsq $0x400000004, %rcx      # imm = 0x400000004
movq %rcx, 0x10(%rax)
movq %rcx, 0x8(%rax)
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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[3]=x1*2;pts[4]=y1*2;pts[5]=z1*2;
    pts[6]=x2*2;pts[7]=y2*2;pts[8]=z2*2;
    pts[9]=x3*2;pts[10]=y3*2;pts[11]=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 0x1c2df
movq 0x40(%rdi), %rax
xorl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
incq %rcx
movslq 0xc(%rdi), %rdx
cmpq %rdx, %rcx
jl 0x1c2cc
movq $0x4, 0x18(%rdi)
movq 0x40(%rdi), %rax
movl $0x4, 0xc(%rax)
addsd %xmm0, %xmm0
movq 0x30(%rdi), %rax
movsd %xmm0, (%rax)
addsd %xmm1, %xmm1
movsd %xmm1, 0x8(%rax)
addsd %xmm2, %xmm2
movsd %xmm2, 0x10(%rax)
addsd %xmm3, %xmm3
movsd %xmm3, 0x18(%rax)
addsd %xmm4, %xmm4
movsd %xmm4, 0x20(%rax)
addsd %xmm5, %xmm5
movsd %xmm5, 0x28(%rax)
addsd %xmm6, %xmm6
movsd %xmm6, 0x30(%rax)
addsd %xmm7, %xmm7
movsd %xmm7, 0x38(%rax)
addsd %xmm11, %xmm11
movsd %xmm11, 0x40(%rax)
addsd %xmm10, %xmm10
movsd %xmm10, 0x48(%rax)
addsd %xmm9, %xmm9
movsd %xmm9, 0x50(%rax)
addsd %xmm8, %xmm8
movsd %xmm8, 0x58(%rax)
movq 0x48(%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 0x333c0(%rip), %xmm0    # 0x4f760
movups %xmm0, 0x20(%rax)
movaps 0x333c5(%rip), %xmm0    # 0x4f770
movups %xmm0, 0x30(%rax)
leaq 0x38(%rax), %rdx
movaps 0x333c6(%rip), %xmm0    # 0x4f780
movups %xmm0, 0x40(%rax)
movaps 0x333cb(%rip), %xmm0    # 0x4f790
movups %xmm0, 0x50(%rax)
leaq 0x54(%rax), %rsi
movaps 0x333cc(%rip), %xmm0    # 0x4f7a0
movups %xmm0, 0x60(%rax)
movq 0x20(%rdi), %r8
movq %rax, (%r8)
movq 0x20(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rdi), %rax
movq %rdx, 0x10(%rax)
movq 0x20(%rdi), %rax
movq %rsi, 0x18(%rax)
movq 0x28(%rdi), %rax
movabsq $0x300000003, %rcx      # imm = 0x300000003
movq %rcx, 0x8(%rax)
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::max_radius_squared()
double voronoicell_base::max_radius_squared() {
    double r,s,*ptsp=pts+3,*ptse=pts+3*p;
    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++;
        if(s>r) r=s;
    }
    return r;
}

// Assembly:
movq 0x30(%rdi), %rax
movslq 0x18(%rdi), %rcx
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
cmpq $0x2, %rcx
jl 0x1d122
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
addq $0x18, %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 $0x18, %rax
movapd %xmm0, %xmm1
cmpq %rcx, %rax
jb 0x1d0ee
retq
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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[3*k]-pts[3*i];
            dy=pts[3*k+1]-pts[3*i+1];
            dz=pts[3*k+2]-pts[3*i+2]; 
            dis+=sqrt(dx*dx+dy*dy+dz*dz);
        }
    }
    return 0.5*dis;
}

// Assembly:
xorpd %xmm3, %xmm3
cmpl $0x2, 0x18(%rdi)
jl 0x1d219
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm4, %xmm4
xorl %r14d, %r14d
xorpd %xmm3, %xmm3
movq 0x28(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0x1d1f3
leaq (,%r14,8), %rax
leaq (%rax,%rax,2), %r15
xorl %r12d, %r12d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rax
movslq (%rax,%r12,4), %rax
cmpq %rax, %r14
jge 0x1d1df
movq 0x30(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movsd (%rcx,%rax,8), %xmm1
movsd 0x8(%rcx,%rax,8), %xmm2
subsd (%rcx,%r15), %xmm1
subsd 0x8(%rcx,%r15), %xmm2
movsd 0x10(%rcx,%rax,8), %xmm0
subsd 0x10(%rcx,%r15), %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm4, %xmm0
jb 0x1d1c8
sqrtsd %xmm0, %xmm0
jmp 0x1d1db
movsd %xmm3, (%rsp)
callq 0x72d0
xorpd %xmm4, %xmm4
movsd (%rsp), %xmm3
addsd %xmm0, %xmm3
incq %r12
movq 0x28(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r12
jl 0x1d16a
incq %r14
movslq 0x18(%rbx), %rax
decq %rax
cmpq %rax, %r14
jl 0x1d14c
mulsd 0x3236a(%rip), %xmm3    # 0x4f578
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movapd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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+=3) {
        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+3*k;
                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, 0x18(%rdi)
jle 0x1d385
movq %rdi, %r14
movq 0x30(%rdi), %r13
leaq 0xa0(%rsp), %r12
leaq 0x20(%rsp), %rbp
xorl %r15d, %r15d
movsd (%r13), %xmm0
movsd 0x32304(%rip), %xmm3    # 0x4f578
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 0x32803(%rip), %rsi     # 0x4faab
movb $0x3, %al
callq 0x70b0
movq (%rsp), %rdi
leaq 0x327fa(%rip), %rsi     # 0x4fab4
movq %r12, %rdx
xorl %eax, %eax
callq 0x7540
movq 0x28(%r14), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0x1d371
xorl %ebx, %ebx
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rax
movslq (%rax,%rbx,4), %rax
cmpq %rax, %r15
jle 0x1d35d
movq 0x30(%r14), %rcx
leaq (%rax,%rax,2), %rax
movsd (%rcx,%rax,8), %xmm0
movsd 0x3227d(%rip), %xmm3    # 0x4f578
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 0x3277c(%rip), %rsi     # 0x4faab
movb $0x3, %al
callq 0x70b0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x7500
testl %eax, %eax
je 0x1d35d
movq (%rsp), %rdi
leaq 0x32774(%rip), %rsi     # 0x4fac4
movq %r12, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x7540
incq %rbx
movq 0x28(%r14), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %rbx
jl 0x1d2d5
incq %r15
addq $0x18, %r13
movslq 0x18(%r14), %rax
cmpq %rax, %r15
jl 0x1d266
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::check_marginal(int, double&)
int voronoicell_base::check_marginal(int n,double &ans) {
    int i;
    for(i=0;i<n_marg;i+=2) if(marg[i]==n) return marg[i+1];
    if(n_marg==current_marginal) {
        current_marginal<<=1;
        if(current_marginal>max_marginal)
            voro_fatal_error("Marginal case buffer allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
        fprintf(stderr,"Marginal cases buffer scaled up to %d\n",i);
#endif
        int *pmarg=new int[current_marginal];
        for(int j=0;j<n_marg;j++) pmarg[j]=marg[j];
        delete [] marg;
        marg=pmarg;
    }
    marg[n_marg++]=n;
    marg[n_marg++]=ans>tolerance?1:(ans<-tolerance?-1:0);
    return marg[n_marg-1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x74(%rdi), %r12
testq %r12, %r12
jle 0x1df09
movq 0x78(%rbx), %rax
xorl %ecx, %ecx
cmpl %ebp, (%rax,%rcx,4)
je 0x1dfbd
addq $0x2, %rcx
cmpl %ecx, %r12d
jg 0x1def7
movl 0x70(%rbx), %eax
cmpl %eax, %r12d
jne 0x1df69
addl %eax, %eax
movl %eax, 0x70(%rbx)
cmpl $0x1000001, %eax        # imm = 0x1000001
jge 0x1dfd5
movslq %eax, %rcx
shlq $0x2, %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, %r15
testl %r12d, %r12d
jle 0x1df57
movq 0x78(%rbx), %rax
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movl %edx, (%r15,%rcx,4)
incq %rcx
cmpq %rcx, %r12
jne 0x1df48
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1df65
callq 0x7480
movq %r15, 0x78(%rbx)
movq 0x78(%rbx), %rax
movslq 0x74(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x74(%rbx)
movl %ebp, (%rax,%rcx,4)
movsd (%r14), %xmm0
movsd 0x315f9(%rip), %xmm1    # 0x4f580
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
negl %ecx
ucomisd 0x315ee(%rip), %xmm0    # 0x4f588
movl $0x1, %edx
cmovbel %ecx, %edx
movslq 0x74(%rbx), %rcx
leal 0x1(%rcx), %esi
movl %esi, 0x74(%rbx)
movl %edx, (%rax,%rcx,4)
movslq 0x74(%rbx), %rcx
leaq (%rax,%rcx,4), %rax
addq $-0x4, %rax
jmp 0x1dfca
movl %ecx, %ecx
shlq $0x2, %rcx
orq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x7c50
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x18(%rdi), %rax
leaq (%rax,%rax,2), %rsi
movq %rbx, %rdi
callq 0x25ac8
movl 0x18(%r14), %eax
testl %eax, %eax
jle 0x1e2d6
leaq (%rax,%rax,2), %rax
movq 0x30(%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd 0x312d9(%rip), %xmm0    # 0x4f578
movsd (%rcx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
movsd 0x8(%rcx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdx,%rsi,8)
movsd 0x10(%rcx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdx,%rsi,8)
addq $0x3, %rsi
cmpq %rax, %rsi
jb 0x1e29f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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;
    }
}

// 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 0x18(%rdi), %rax
leaq (%rax,%rax,2), %rsi
movq %rbx, %rdi
callq 0x25ac8
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
movl 0x18(%r14), %eax
testl %eax, %eax
jle 0x1e43d
leaq (%rax,%rax,2), %rax
movq 0x30(%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd 0x3117e(%rip), %xmm0    # 0x4f578
movsd (%rcx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm4, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
movsd 0x8(%rcx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
movsd %xmm1, 0x8(%rdx,%rsi,8)
movsd 0x10(%rcx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rdx,%rsi,8)
addq $0x3, %rsi
cmpq %rax, %rsi
jb 0x1e3fa
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::plane_intersects_guess(double, double, double, double)
bool voronoicell_base::plane_intersects_guess(double x,double y,double z,double rsq) {
    up=0;
    double g=x*pts[3*up]+y*pts[3*up+1]+z*pts[3*up+2];
    if(g<rsq) {
        int ca=1,cc=p>>3,mp=1;
        double m;
        while(ca<cc) {
            m=x*pts[3*mp]+y*pts[3*mp+1]+z*pts[3*mp+2];
            if(m>g) {
                if(m>rsq) return true;
                g=m;up=mp;
            }
            ca+=mp++;
        }
        return plane_intersects_track(x,y,z,rsq,g);
    }
    return true;
}

// Assembly:
movl $0x0, 0x1c(%rdi)
movq 0x30(%rdi), %rax
movsd 0x8(%rax), %xmm4
mulsd %xmm1, %xmm4
movsd (%rax), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
movsd 0x10(%rax), %xmm4
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
ucomisd %xmm4, %xmm3
jbe 0x1edb6
movl 0x18(%rdi), %ecx
sarl $0x3, %ecx
cmpl $0x2, %ecx
jl 0x25b2e
addq $0x28, %rax
movl $0x1, %edx
movl $0x1, %esi
movsd -0x8(%rax), %xmm5
mulsd %xmm1, %xmm5
movsd -0x10(%rax), %xmm6
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
movsd (%rax), %xmm5
mulsd %xmm2, %xmm5
addsd %xmm6, %xmm5
ucomisd %xmm4, %xmm5
jbe 0x1eda5
ucomisd %xmm3, %xmm5
ja 0x1edb6
movl %edx, 0x1c(%rdi)
movapd %xmm5, %xmm4
addl %edx, %esi
addq $0x18, %rax
incl %edx
cmpl %ecx, %esi
jl 0x1ed70
jmp 0x25b2e
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_neighbor::init(double, double, double, double, double, double)
void voronoicell_neighbor::init(double xmin,double xmax,double ymin,double ymax,double zmin,double zmax) {
    init_base(xmin,xmax,ymin,ymax,zmin,zmax);
    int *q=mne[3];
    *q=-5;q[1]=-3;q[2]=-1;
    q[3]=-5;q[4]=-2;q[5]=-3;
    q[6]=-5;q[7]=-1;q[8]=-4;
    q[9]=-5;q[10]=-4;q[11]=-2;
    q[12]=-6;q[13]=-1;q[14]=-3;
    q[15]=-6;q[16]=-3;q[17]=-2;
    q[18]=-6;q[19]=-4;q[20]=-1;
    q[21]=-6;q[22]=-2;q[23]=-4;
    *ne=q;ne[1]=q+3;ne[2]=q+6;ne[3]=q+9;
    ne[4]=q+12;ne[5]=q+15;ne[6]=q+18;ne[7]=q+21;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1bef2
movq 0xa0(%rbx), %rax
movq 0x18(%rax), %rax
movaps 0x30545(%rip), %xmm0    # 0x4f7b0
movups %xmm0, (%rax)
leaq 0xc(%rax), %rcx
movaps 0x30547(%rip), %xmm0    # 0x4f7c0
movups %xmm0, 0x10(%rax)
leaq 0x18(%rax), %rdx
movaps 0x30548(%rip), %xmm0    # 0x4f7d0
movups %xmm0, 0x20(%rax)
leaq 0x24(%rax), %rsi
leaq 0x30(%rax), %rdi
movaps 0x30545(%rip), %xmm0    # 0x4f7e0
movups %xmm0, 0x30(%rax)
leaq 0x3c(%rax), %r8
movaps 0x30546(%rip), %xmm0    # 0x4f7f0
movups %xmm0, 0x40(%rax)
leaq 0x48(%rax), %r9
movaps 0x30547(%rip), %xmm0    # 0x4f800
movups %xmm0, 0x50(%rax)
movq 0xa8(%rbx), %r10
movq %rax, (%r10)
addq $0x54, %rax
movq 0xa8(%rbx), %r10
movq %rcx, 0x8(%r10)
movq 0xa8(%rbx), %rcx
movq %rdx, 0x10(%rcx)
movq 0xa8(%rbx), %rcx
movq %rsi, 0x18(%rcx)
movq 0xa8(%rbx), %rcx
movq %rdi, 0x20(%rcx)
movq 0xa8(%rbx), %rcx
movq %r8, 0x28(%rcx)
movq 0xa8(%rbx), %rcx
movq %r9, 0x30(%rcx)
movq 0xa8(%rbx), %rcx
movq %rax, 0x38(%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_neighbor::init_octahedron(double)
void voronoicell_neighbor::init_octahedron(double l) {
    init_octahedron_base(l);
    int *q=mne[4];
    *q=-5;q[1]=-6;q[2]=-7;q[3]=-8;
    q[4]=-1;q[5]=-2;q[6]=-3;q[7]=-4;
    q[8]=-6;q[9]=-5;q[10]=-2;q[11]=-1;
    q[12]=-8;q[13]=-7;q[14]=-4;q[15]=-3;
    q[16]=-5;q[17]=-8;q[18]=-3;q[19]=-2;
    q[20]=-7;q[21]=-6;q[22]=-1;q[23]=-4;
    *ne=q;ne[1]=q+4;ne[2]=q+8;ne[3]=q+12;ne[4]=q+16;ne[5]=q+20;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1c10a
movq 0xa0(%rbx), %rax
movq 0x20(%rax), %rax
movaps 0x304db(%rip), %xmm0    # 0x4f810
movups %xmm0, (%rax)
leaq 0x10(%rax), %rcx
movaps 0x304dd(%rip), %xmm0    # 0x4f820
movups %xmm0, 0x10(%rax)
leaq 0x20(%rax), %rdx
movaps 0x304de(%rip), %xmm0    # 0x4f830
movups %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rsi
movaps 0x304df(%rip), %xmm0    # 0x4f840
movups %xmm0, 0x30(%rax)
leaq 0x40(%rax), %rdi
movaps 0x304e0(%rip), %xmm0    # 0x4f850
movups %xmm0, 0x40(%rax)
leaq 0x50(%rax), %r8
movaps 0x304e1(%rip), %xmm0    # 0x4f860
movups %xmm0, 0x50(%rax)
movq 0xa8(%rbx), %r9
movq %rax, (%r9)
movq 0xa8(%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0xa8(%rbx), %rax
movq %rdx, 0x10(%rax)
movq 0xa8(%rbx), %rax
movq %rsi, 0x18(%rax)
movq 0xa8(%rbx), %rax
movq %rdi, 0x20(%rax)
movq 0xa8(%rbx), %rax
movq %r8, 0x28(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_neighbor::init_tetrahedron(double, double, double, double, double, double, double, double, double, double, double, double)
void voronoicell_neighbor::init_tetrahedron(double x0,double y0,double z0,double x1,double y1,double z1,double x2,double y2,double z2,double x3,double y3,double z3) {
    init_tetrahedron_base(x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3);
    int *q=mne[3];
    *q=-4;q[1]=-3;q[2]=-2;
    q[3]=-3;q[4]=-4;q[5]=-1;
    q[6]=-4;q[7]=-2;q[8]=-1;
    q[9]=-2;q[10]=-3;q[11]=-1;
    *ne=q;ne[1]=q+3;ne[2]=q+6;ne[3]=q+9;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movaps 0x30(%rsp), %xmm8
movaps 0x40(%rsp), %xmm9
movups %xmm9, 0x10(%rsp)
movups %xmm8, (%rsp)
callq 0x1c2a4
movq 0xa0(%rbx), %rax
movq 0x18(%rax), %rax
movaps 0x30474(%rip), %xmm0    # 0x4f870
movups %xmm0, (%rax)
leaq 0xc(%rax), %rcx
movaps 0x30476(%rip), %xmm0    # 0x4f880
movups %xmm0, 0x10(%rax)
leaq 0x18(%rax), %rdx
movaps 0x30477(%rip), %xmm0    # 0x4f890
movups %xmm0, 0x20(%rax)
movq 0xa8(%rbx), %rsi
movq %rax, (%rsi)
addq $0x24, %rax
movq 0xa8(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0xa8(%rbx), %rcx
movq %rdx, 0x10(%rcx)
movq 0xa8(%rbx), %rcx
movq %rax, 0x18(%rcx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_neighbor::voronoicell_neighbor()
voronoicell_neighbor::voronoicell_neighbor() {
    int i;
    mne=new int*[current_vertex_order];
    ne=new int*[current_vertices];
    for(i=0;i<3;i++) mne[i]=new int[init_n_vertices*i];
    mne[3]=new int[init_3_vertices*3];
    for(i=4;i<current_vertex_order;i++) mne[i]=new int[init_n_vertices*i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1b948
leaq 0x426c7(%rip), %rax     # 0x61cc0
movq %rax, (%rbx)
movslq 0xc(%rbx), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
movq $-0x1, %r14
cmovsq %r14, %rdi
callq 0x7030
movq %rax, 0xa0(%rbx)
movslq 0x8(%rbx), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
cmovsq %r14, %rdi
callq 0x7030
movq %rax, 0xa8(%rbx)
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x7030
movq 0xa0(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
addq $0x20, %r14
cmpq $0x3, %r12
jne 0x1f647
movl $0xc00, %edi            # imm = 0xC00
callq 0x7030
movq 0xa0(%rbx), %rcx
movq %rax, 0x18(%rcx)
cmpl $0x5, %r15d
jl 0x1f6b2
shlq $0x5, %r15
movl $0x80, %r14d
movl $0x8, %r12d
movq %r14, %rdi
callq 0x7030
movq 0xa0(%rbx), %rcx
movq %rax, (%rcx,%r12,4)
addq $0x20, %r14
addq $0x2, %r12
cmpq %r14, %r15
jne 0x1f692
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1f6c2
jmp 0x1f6c2
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bad4
movq %r14, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::m_test(int, double&)
inline int voronoicell_base::m_test(int n,double &ans) {
    double *pp=pts+n+(n<<1);
    ans=*(pp++)*px;
    ans+=*(pp++)*py;
    ans+=*pp*pz-prsq;
    if(ans<-tolerance2) {
        return -1;
    } else if(ans>tolerance2) {
        return 1;
    }
    return check_marginal(n,ans);
}

// Assembly:
movslq %esi, %rax
leaq (,%rax,8), %rcx
addq 0x30(%rdi), %rcx
addl %eax, %eax
cltq
movsd (%rcx,%rax,8), %xmm0
mulsd 0x80(%rdi), %xmm0
movsd %xmm0, (%rdx)
movsd 0x8(%rcx,%rax,8), %xmm1
mulsd 0x88(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rdx)
movsd 0x10(%rcx,%rax,8), %xmm0
mulsd 0x90(%rdi), %xmm0
subsd 0x98(%rdi), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movsd 0x2d82b(%rip), %xmm1    # 0x4f550
ucomisd %xmm0, %xmm1
ja 0x21d3e
movl $0x1, %eax
ucomisd 0x2d820(%rip), %xmm0    # 0x4f558
jbe 0x1ded8
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: void voro::voronoicell_base::add_memory_vertices<voro::voronoicell_neighbor>(voro::voronoicell_neighbor&)
void voronoicell_base::add_memory_vertices(vc_class &vc) {
    int i=(current_vertices<<1),j,**pp,*pnu;
    if(i>max_vertices) voro_fatal_error("Vertex memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
    fprintf(stderr,"Vertex memory scaled up to %d\n",i);
#endif
    double *ppts;
    pp=new int*[i];
    for(j=0;j<current_vertices;j++) pp[j]=ed[j];
    delete [] ed;ed=pp;
    vc.n_add_memory_vertices(i);
    pnu=new int[i];
    for(j=0;j<current_vertices;j++) pnu[j]=nu[j];
    delete [] nu;nu=pnu;
    ppts=new double[3*i];
    for(j=0;j<3*current_vertices;j++) ppts[j]=pts[j];
    delete [] pts;pts=ppts;
    current_vertices=i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x8(%rdi), %r13d
leal (,%r13,2), %ecx
cmpl $0x1000001, %ecx        # imm = 0x1000001
jge 0x24d73
movq %rsi, %r14
movq %rdi, %rbx
movslq %ecx, %rbp
leaq (,%rbp,8), %rax
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
movq $-0x1, %r15
cmovnsq %rax, %r15
movq %r15, %rdi
callq 0x7030
movq %rax, %r12
testl %r13d, %r13d
jle 0x24c53
movq 0x20(%rbx), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq %rdx, (%r12,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0x24c43
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x24c61
callq 0x7480
movq %r12, 0x20(%rbx)
movq %r15, %rdi
callq 0x7030
movq %rax, %r15
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x24c92
movq 0xa8(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x24c82
movq 0xa8(%r14), %rdi
testq %rdi, %rdi
movl 0x4(%rsp), %r12d
je 0x24ca8
callq 0x7480
shlq $0x2, %rbp
testl %r12d, %r12d
movq %r15, 0xa8(%r14)
movq $-0x1, %rdi
cmovnsq %rbp, %rdi
callq 0x7030
movq %rax, %r14
movslq 0x8(%rbx), %rax
testq %rax, %rax
jle 0x24ce7
movq 0x28(%rbx), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
movl %esi, (%r14,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0x24cd8
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x24cf5
callq 0x7480
movq %r14, 0x28(%rbx)
addl %r13d, %r13d
leal (%r13,%r13,2), %eax
cltq
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, %r14
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x24d4e
leal (%rax,%rax,2), %edx
movq 0x30(%rbx), %rax
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%r14,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x24d3b
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x24d5c
callq 0x7480
movq %r14, 0x30(%rbx)
movl %r12d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7a20
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: bool voro::voronoicell_base::search_for_outside_edge<voro::voronoicell>(voro::voronoicell&, int&)
inline bool voronoicell_base::search_for_outside_edge(vc_class &vc,int &up) {
    int i,lp,lw,*j(ds2),*stackp2(ds2);
    double l;
    *(stackp2++)=up;
    while(j<stackp2) {
        up=*(j++);
        for(i=0;i<nu[up];i++) {
            lp=ed[up][i];
            lw=m_test(lp,l);
            if(lw==-1) return true;
            else if(lw==0) add_to_stack(vc,lp,stackp2);
        }
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %r15
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movl (%rbx), %eax
leaq 0x4(%r15), %rcx
movq %rcx, (%rdx)
movl %eax, (%r15)
movb $0x1, %bpl
movsd 0x2d6ad(%rip), %xmm2    # 0x4f550
movslq (%r15), %rax
movl %eax, (%rbx)
movq 0x28(%r14), %rcx
cmpl $0x0, (%rcx,%rax,4)
jle 0x21fdf
xorl %r12d, %r12d
movq 0x20(%r14), %rcx
movq (%rcx,%rax,8), %rax
movslq (%rax,%r12,4), %r13
movq %r13, %rax
shlq $0x3, %rax
addq 0x30(%r14), %rax
leal (,%r13,2), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0x80(%r14), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rax,%rcx,8), %xmm1
mulsd 0x88(%r14), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rax,%rcx,8), %xmm0
mulsd 0x90(%r14), %xmm0
subsd 0x98(%r14), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd %xmm0, %xmm2
ja 0x21f5c
movl $0x1, %eax
ucomisd 0x2d616(%rip), %xmm0    # 0x4f558
ja 0x21f5c
movq %r14, %rdi
movl %r13d, %esi
leaq 0x10(%rsp), %rdx
callq 0x1ded8
movsd 0x2d5f4(%rip), %xmm2    # 0x4f550
testl %eax, %eax
je 0x21f6a
cmpl $-0x1, %eax
jne 0x21fc8
jmp 0x21ff2
movq 0x60(%r14), %rcx
movq 0x8(%rsp), %rax
cmpq %rax, %rcx
setb %dl
jae 0x21f9c
cmpl %r13d, (%rcx)
je 0x21f98
addq $0x4, %rcx
cmpq %rax, %rcx
setb %dl
jae 0x21f9c
leaq 0x4(%rcx), %rsi
cmpl %r13d, (%rcx)
movq %rsi, %rcx
jne 0x21f84
testb %dl, %dl
jne 0x21fc8
cmpq 0x68(%r14), %rax
jne 0x21fb7
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b820
movsd 0x2d599(%rip), %xmm2    # 0x4f550
movq 0x8(%rsp), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl %r13d, (%rax)
incq %r12
movq 0x28(%r14), %rcx
movslq (%rbx), %rax
movslq (%rcx,%rax,4), %rcx
cmpq %rcx, %r12
jl 0x21eb9
addq $0x4, %r15
cmpq 0x8(%rsp), %r15
setb %bpl
jb 0x21ea3
andb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/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)
movl 0xc(%rdi), %r14d
leal (%r14,%r14), %ebp
cmpl $0x801, %ebp            # imm = 0x801
jge 0x250af
movq %rdi, %rbx
movslq %ebp, %r13
leaq (,%r13,4), %rax
testl %ebp, %ebp
movq $-0x1, %r15
cmovnsq %rax, %r15
movq %r15, %rdi
callq 0x7030
movq %rax, %r12
testl %r14d, %r14d
jle 0x24f79
movq 0x38(%rbx), %rcx
xorl %eax, %eax
movl (%rcx,%rax,4), %edx
movl %edx, (%r12,%rax,4)
incq %rax
cmpq %rax, %r14
jne 0x24f68
jmp 0x24f7b
xorl %eax, %eax
cmpl %ebp, %eax
movq (%rsp), %r14
jge 0x24f9c
movl %eax, %ecx
leaq (%r12,%rcx,4), %rdi
notl %eax
addl %ebp, %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x71e0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x24faa
callq 0x7480
shlq $0x3, %r13
testl %ebp, %ebp
movq %r12, 0x38(%rbx)
movq $-0x1, %r12
cmovnsq %r13, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r13
movslq 0xc(%rbx), %rax
testq %rax, %rax
jle 0x24fea
movq 0x48(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%r13,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x24fd9
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x24ff8
callq 0x7480
movq %r13, 0x48(%rbx)
movq %r15, %rdi
callq 0x7030
movq %rax, %r15
movslq 0xc(%rbx), %rcx
testq %rcx, %rcx
jle 0x25027
movq 0x40(%rbx), %rdx
xorl %eax, %eax
movl (%rdx,%rax,4), %esi
movl %esi, (%r15,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x25016
jmp 0x25029
xorl %eax, %eax
cmpl %ebp, %eax
jge 0x25046
movl %eax, %ecx
leaq (%r15,%rcx,4), %rdi
notl %eax
addl %ebp, %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x71e0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x25054
callq 0x7480
movq %r15, 0x40(%rbx)
movq %r12, %rdi
callq 0x7030
movq %rax, %r15
movslq 0xc(%r14), %rax
testq %rax, %rax
jle 0x25085
movq 0xa0(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x25075
movq 0xa0(%r14), %rdi
testq %rdi, %rdi
je 0x25096
callq 0x7480
movq %r15, 0xa0(%r14)
movl %ebp, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7a48
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: bool voro::voronoicell_base::collapse_order1<voro::voronoicell_neighbor>(voro::voronoicell_neighbor&)
inline bool voronoicell_base::collapse_order1(vc_class &vc) {
    int i,j,k;
    while(mec[1]>0) {
        up=0;
#if VOROPP_VERBOSE >=1
        fputs("Order one collapse\n",stderr);
#endif
        i=--mec[1];
        j=mep[1][3*i];k=mep[1][3*i+1];
        i=mep[1][3*i+2];
        if(!delete_connection(vc,j,k,false)) return false;
        --p;
        if(up==i) up=0;
        if(p!=i) {
            if(up==p) up=i;
            pts[3*i]=pts[3*p];
            pts[3*i+1]=pts[3*p+1];
            pts[3*i+2]=pts[3*p+2];
            for(k=0;k<nu[p];k++) ed[ed[p][k]][ed[p][nu[p]+k]]=i;
            vc.n_copy_pointer(i,p);
            ed[i]=ed[p];
            nu[i]=nu[p];
            ed[i][nu[i]<<1]=i;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rax
cmpl $0x0, 0x4(%rax)
setle %bpl
jle 0x26bb3
movq %rsi, %rbx
movq %rdi, %r14
addq $0x4, %rax
movl $0x0, 0x1c(%r14)
movslq (%rax), %rcx
decq %rcx
movl %ecx, (%rax)
movq 0x48(%r14), %rax
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rsi
movl (%rax,%rsi,4), %edx
movl 0x4(%rax,%rsi,4), %ecx
movl 0x8(%rax,%rsi,4), %r15d
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x26bc4
testb %al, %al
je 0x26bb3
movslq 0x18(%r14), %rcx
decq %rcx
movl %ecx, 0x18(%r14)
cmpl %r15d, 0x1c(%r14)
jne 0x26ae2
movl $0x0, 0x1c(%r14)
cmpl %r15d, %ecx
je 0x26b9d
cmpl %ecx, 0x1c(%r14)
jne 0x26af5
movl %r15d, 0x1c(%r14)
movslq %r15d, %rax
movq 0x30(%r14), %rdx
leaq (%rcx,%rcx,2), %rcx
movsd (%rdx,%rcx,8), %xmm0
leaq (%rax,%rax,2), %rsi
movsd %xmm0, (%rdx,%rsi,8)
movsd 0x8(%rdx,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rdx,%rsi,8)
movsd 0x10(%rdx,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rdx,%rsi,8)
movq 0x28(%r14), %rdx
movslq 0x18(%r14), %rcx
movl (%rdx,%rcx,4), %r8d
testl %r8d, %r8d
jle 0x26b67
movq 0x20(%r14), %rsi
xorl %edi, %edi
movq (%rsi,%rcx,8), %rcx
movslq (%rcx,%rdi,4), %r9
movq (%rsi,%r9,8), %r9
movslq %r8d, %r8
addq %rdi, %r8
movslq (%rcx,%r8,4), %rcx
movl %r15d, (%r9,%rcx,4)
incq %rdi
movslq 0x18(%r14), %rcx
movslq (%rdx,%rcx,4), %r8
cmpq %r8, %rdi
jl 0x26b3d
movq 0xa8(%rbx), %rdx
movq (%rdx,%rcx,8), %rsi
movq %rsi, (%rdx,%rax,8)
movq 0x20(%r14), %rdx
movq (%rdx,%rcx,8), %rsi
movq %rsi, (%rdx,%rax,8)
movq 0x28(%r14), %rdx
movl (%rdx,%rcx,4), %ecx
movl %ecx, (%rdx,%rax,4)
movq 0x20(%r14), %rdx
movq (%rdx,%rax,8), %rax
addl %ecx, %ecx
movslq %ecx, %rcx
movl %r15d, (%rax,%rcx,4)
movq 0x40(%r14), %rcx
leaq 0x4(%rcx), %rax
cmpl $0x0, 0x4(%rcx)
setle %bpl
jg 0x26a8b
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/container.cc
// Function: voro::container_base::~container_base()
container_base::~container_base() {
    int l;
    for(l=0;l<nxyz;l++) delete [] p[l];
    for(l=0;l<nxyz;l++) delete [] id[l];
    delete [] id;
    delete [] p;
    delete [] co;
    delete [] mem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jle 0x275ad
xorl %r14d, %r14d
movq 0xb0(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x275a1
callq 0x7480
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x2758c
cmpl $0x0, 0x10(%rbx)
jle 0x275d7
xorl %r14d, %r14d
movq 0xa8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x275cb
callq 0x7480
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x275b6
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x275e8
callq 0x7480
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x275f9
callq 0x7480
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x2760a
callq 0x7480
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x2761b
callq 0x7480
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x27629
callq 0x7480
movq 0x48(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x2763e
popq %rbx
popq %r14
jmp 0x7480
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/container.cc
// Function: voro::container::put(int, double, double, double)
void container::put(int n,double x,double y,double z) {
    int ijk;
    if(put_locate_block(ijk,x,y,z)) {
        id[ijk][co[ijk]]=n;
        double *pp=p[ijk]+3*co[ijk]++;
        *(pp++)=x;*(pp++)=y;*pp=z;
    }
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x18(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x10(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0xc(%rsp), %rsi
callq 0x27832
testb %al, %al
je 0x27a1c
movslq 0xc(%rsp), %rax
movq 0xa8(%rbx), %rcx
movq 0xb8(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rax
movl %ebp, (%rcx,%rax,4)
movslq 0xc(%rsp), %r15
movl (%rdx,%r15,4), %ebp
movslq 0x10(%r14), %rax
shlq $0x2, %rax
addq (%r14), %rax
cmpq %rax, 0x8(%r14)
jne 0x279ba
movq %r14, %rdi
callq 0x42c8e
movq 0x8(%r14), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %r15d, (%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %ebp, 0x4(%rax)
movslq 0xc(%rsp), %rax
movq 0xb0(%rbx), %rcx
movq 0xb8(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rdx,%rax,4)
leaq (%rsi,%rsi,2), %rax
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rcx,%rax,8)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rax,8)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rax,8)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop