LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/ot.cc
// Function: vot::OT::cluster()
void OT::cluster() {
        int iterD = 0;
        mDiagram->write_results(0, 0, mOutFilePrefix);
        while (iterD < mMaxIterD) {
            // OT 
            int iterH = 0;
            while (iterH < mMaxIterH) {
                if (mDiagram->update(mMethod, mThres, mLearnRate, iterD, iterH)) {
                    break;
                }
                iterH++;
                // mDiagram->write_results(iterD, iterH, mOutFilePrefix);
            }
            // Update dirac
            if (mDiagram->update_dirac()) {
                break;
            }
            iterD++;
            mDiagram->write_results(iterD, 0, mOutFilePrefix);
        }
        // mDiagram->write_results(iterD, iterH, mOutFilePrefix);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq (%rdi), %r12
leaq 0x8(%rdi), %r15
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74d0
xorl %ebp, %ebp
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xdf24
movq %rsp, %rdi
callq 0x77f8
leaq 0x20(%rsp), %rbx
cmpl 0x2c(%r14), %ebp
jge 0x1699e
xorl %r12d, %r12d
cmpl 0x30(%r14), %r12d
jge 0x16969
movq (%r14), %rdi
movl 0x48(%r14), %esi
movsd 0x38(%r14), %xmm0
movsd 0x40(%r14), %xmm1
movl %ebp, %edx
movl %r12d, %ecx
callq 0xe526
incl %r12d
testb %al, %al
je 0x1693f
movq (%r14), %rdi
callq 0xeafa
testb %al, %al
jne 0x1699e
incl %ebp
movq (%r14), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74d0
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xdf24
movq %rbx, %rdi
callq 0x77f8
jmp 0x16936
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x169ad
movq %rax, %r14
movq %rbx, %rdi
callq 0x77f8
movq %r14, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::add_memory_ds2(int*&)
void voronoicell_base::add_memory_ds2(int *&stackp2) {
    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 %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x14(%rdi), %eax
addl %eax, %eax
movl %eax, 0x14(%rdi)
cmpl $0x1000001, %eax        # imm = 0x1000001
jl 0x16ba0
leaq 0x2ddc5(%rip), %rdi     # 0x4495a
pushq $0x2
popq %rsi
callq 0x1c1ae
movl 0x14(%rbx), %eax
movslq %eax, %r12
leaq (,%r12,4), %rax
testl %r12d, %r12d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x7030
movq %rax, %r15
movq 0x60(%rbx), %rdi
movq (%r14), %rax
movq %r15, %r13
movq %rdi, %rcx
cmpq %rax, %rcx
jae 0x16bdf
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r13)
addq $0x4, %r13
jmp 0x16bca
testq %rdi, %rdi
je 0x16bed
callq 0x7470
movslq 0x14(%rbx), %r12
movq %r15, 0x60(%rbx)
movq %r13, (%r14)
shlq $0x2, %r12
addq 0x60(%rbx), %r12
movq %r12, 0x68(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::add_memory_ds(int*&)
void voronoicell_base::add_memory_ds(int *&stackp) {
    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 %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %eax
addl %eax, %eax
movl %eax, 0x10(%rdi)
cmpl $0x1000001, %eax        # imm = 0x1000001
jl 0x16c3a
leaq 0x2dcf0(%rip), %rdi     # 0x4491f
pushq $0x2
popq %rsi
callq 0x1c1ae
movl 0x10(%rbx), %eax
movslq %eax, %r12
leaq (,%r12,4), %rax
testl %r12d, %r12d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x7030
movq %rax, %r15
movq 0x50(%rbx), %rdi
movq (%r14), %rax
movq %r15, %r13
movq %rdi, %rcx
cmpq %rax, %rcx
jae 0x16c79
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r13)
addq $0x4, %r13
jmp 0x16c64
testq %rdi, %rdi
je 0x16c87
callq 0x7470
movslq 0x10(%rbx), %r12
movq %r15, 0x50(%rbx)
movq %r13, (%r14)
shlq $0x2, %r12
addq 0x50(%rbx), %r12
movq %r12, 0x58(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43ff2(%rip), %rax     # 0x5aca8
movq %rax, (%rdi)
movaps 0x2d820(%rip), %xmm0    # 0x444e0
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)
pushq $0x20
popq %r14
xorl %r15d, %r15d
movq 0x38(%rbx), %rax
cmpq $0xe0, %r14
je 0x16d9b
movl $0x8, (%rax,%r15,4)
movq 0x40(%rbx), %rax
andl $0x0, (%rax,%r15,4)
movq %r14, %rdi
callq 0x7030
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
addq $0x40, %r14
jmp 0x16d64
movl $0x100, 0xc(%rax)       # imm = 0x100
movq 0x40(%rbx), %rax
andl $0x0, 0xc(%rax)
movl $0x1c00, %edi           # imm = 0x1C00
callq 0x7030
movq 0x48(%rbx), %rcx
movq %rax, 0x18(%rcx)
pushq $0x4
popq %r14
pushq $0x40
popq %r15
pushq $-0x1
popq %r12
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jge 0x16e0e
movq 0x38(%rbx), %rax
movl $0x8, (%rax,%r14,4)
movq 0x40(%rbx), %rax
andl $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
addl $0x10, %r15d
jmp 0x16dc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43e80(%rip), %rax     # 0x5aca8
movq %rax, (%rdi)
movl 0xc(%rdi), %r14d
testl %r14d, %r14d
jle 0x16e58
movq 0x38(%rbx), %rax
cmpl $0x0, -0x4(%rax,%r14,4)
jle 0x16e53
movq 0x48(%rbx), %rax
movq -0x8(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x16e53
callq 0x7470
decq %r14
jmp 0x16e2f
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x16e66
callq 0x7470
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x16e74
callq 0x7470
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x16e82
callq 0x7470
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x16e90
callq 0x7470
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x16e9e
callq 0x7470
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x16eac
callq 0x7470
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x16eba
callq 0x7470
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x16ec8
callq 0x7470
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x16edd
popq %rbx
popq %r14
jmp 0x7470
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rdi)
andl $0x0, 0x1c(%rdi)
movabsq $0x4, %rax
movl $0x1, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
movslq 0xc(%rdi), %r9
cmpq %r9, %r8
jge 0x16fa6
movq 0x40(%rsi), %r9
movl (%r9,%r8,4), %r10d
movq 0x40(%rdi), %r11
movl %r10d, (%r11,%r8,4)
movq 0x48(%rdi), %rbx
leal 0x1(,%r8,2), %r9d
xorl %r14d, %r14d
movl %r10d, %ebp
imull %r9d, %ebp
movslq %ebp, %r15
cmpq %r15, %r14
jge 0x16f5e
movq 0x48(%rsi), %r10
movq (%r10,%r8,8), %r10
movl (%r10,%r14,4), %r10d
movq (%rbx,%r8,8), %r15
movl %r10d, (%r15,%r14,4)
incq %r14
movl (%r11,%r8,4), %r10d
jmp 0x16f32
xorl %r11d, %r11d
xorl %ebx, %ebx
imull %r9d, %r10d
cmpl %r11d, %r10d
jle 0x16f93
movq 0x20(%rdi), %r10
movq 0x48(%rdi), %r14
movq (%r14,%r8,8), %r14
addq %rbx, %r14
movslq (%rdx,%r14), %r15
movq %r14, (%r10,%r15,8)
movq 0x40(%rdi), %r10
movl (%r10,%r8,4), %r10d
addq %rax, %rbx
addl %ecx, %r11d
jmp 0x16f63
incq %r8
addq $0x8, %rdx
addq $0x8, %rax
addl $0x2, %ecx
jmp 0x16f06
movq 0x28(%rdi), %rax
xorl %ecx, %ecx
movslq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
jge 0x16fc4
movq 0x28(%rsi), %rdx
movl (%rdx,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x16fac
leal (%rdx,%rdx,2), %eax
movq 0x30(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x16fea
movq 0x30(%rsi), %rdi
movsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
jmp 0x16fd2
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
addpd %xmm0, %xmm0
addsd %xmm2, %xmm2
movq 0x30(%rdi), %rax
movslq 0x18(%rdi), %rcx
imulq $0x18, %rcx, %rcx
addq %rax, %rcx
cmpq %rcx, %rax
jae 0x171c9
movupd %xmm0, (%rax)
movsd %xmm2, 0x10(%rax)
addq $0x18, %rax
jmp 0x171b5
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x40(%rdi), %rax
xorl %ecx, %ecx
movslq 0xc(%rdi), %rdx
cmpq %rdx, %rcx
jge 0x173ca
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x173b8
movq $0x6, 0x18(%rdi)
movl $0x6, 0x10(%rax)
addsd %xmm0, %xmm0
movapd 0x2777b(%rip), %xmm1    # 0x3eb60
xorpd %xmm0, %xmm1
movq 0x30(%rdi), %rax
movlpd %xmm1, (%rax)
xorps %xmm2, %xmm2
movups %xmm2, 0x8(%rax)
movsd %xmm0, 0x18(%rax)
andq $0x0, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movlpd %xmm1, 0x38(%rax)
movups %xmm2, 0x40(%rax)
movsd %xmm0, 0x50(%rax)
movups %xmm2, 0x58(%rax)
andq $0x0, 0x68(%rax)
movlpd %xmm1, 0x70(%rax)
movups %xmm2, 0x78(%rax)
movsd %xmm0, 0x88(%rax)
movq 0x48(%rdi), %rax
movq 0x20(%rax), %rax
movaps 0x2d1a3(%rip), %xmm0    # 0x445e0
movups %xmm0, (%rax)
leaq 0x24(%rax), %rcx
movups %xmm2, 0x10(%rax)
andl $0x0, 0x20(%rax)
movaps 0x2d19d(%rip), %xmm0    # 0x445f0
movups %xmm0, 0x24(%rax)
movaps 0x2d1a2(%rip), %xmm0    # 0x44600
movups %xmm0, 0x34(%rax)
leaq 0x48(%rax), %rdx
movaps 0x2d1a3(%rip), %xmm0    # 0x44610
movups %xmm0, 0x44(%rax)
movaps 0x2d1a8(%rip), %xmm0    # 0x44620
movups %xmm0, 0x54(%rax)
leaq 0x6c(%rax), %rsi
movaps 0x2d1a9(%rip), %xmm0    # 0x44630
movups %xmm0, 0x64(%rax)
movaps 0x2d1ae(%rip), %xmm0    # 0x44640
movups %xmm0, 0x74(%rax)
leaq 0x90(%rax), %r8
movaps 0x2d1ac(%rip), %xmm0    # 0x44650
movups %xmm0, 0x84(%rax)
movaps 0x2d1ae(%rip), %xmm0    # 0x44660
movups %xmm0, 0x94(%rax)
movaps 0x2d1b0(%rip), %xmm0    # 0x44670
movups %xmm0, 0xa4(%rax)
leaq 0xb4(%rax), %r9
movaps 0x2d1ab(%rip), %xmm0    # 0x44680
movups %xmm0, 0xb4(%rax)
movaps 0x2d1ad(%rip), %xmm0    # 0x44690
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)
movaps 0x2d164(%rip), %xmm0    # 0x446a0
movups %xmm0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %xmm9
movsd 0x18(%rsp), %xmm8
movsd 0x10(%rsp), %xmm11
movsd 0x8(%rsp), %xmm10
movq 0x40(%rdi), %rax
xorl %ecx, %ecx
movslq 0xc(%rdi), %rdx
cmpq %rdx, %rcx
jge 0x17574
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x17562
movq $0x4, 0x18(%rdi)
movl $0x4, 0xc(%rax)
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
addpd %xmm0, %xmm0
movq 0x30(%rdi), %rax
movupd %xmm0, (%rax)
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
addpd %xmm2, %xmm2
movupd %xmm2, 0x10(%rax)
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
addpd %xmm4, %xmm4
movupd %xmm4, 0x20(%rax)
unpcklpd %xmm7, %xmm6            # xmm6 = xmm6[0],xmm7[0]
addpd %xmm6, %xmm6
movupd %xmm6, 0x30(%rax)
unpcklpd %xmm11, %xmm10          # xmm10 = xmm10[0],xmm11[0]
addpd %xmm10, %xmm10
movupd %xmm10, 0x40(%rax)
unpcklpd %xmm9, %xmm8            # xmm8 = xmm8[0],xmm9[0]
addpd %xmm8, %xmm8
movupd %xmm8, 0x50(%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
andl $0x0, 0x1c(%rax)
movupd %xmm0, 0xc(%rax)
movaps 0x2d0a2(%rip), %xmm0    # 0x446b0
movups %xmm0, 0x20(%rax)
leaq 0x38(%rax), %rdx
movaps 0x2d0a3(%rip), %xmm0    # 0x446c0
movups %xmm0, 0x30(%rax)
movaps 0x2d0a8(%rip), %xmm0    # 0x446d0
movups %xmm0, 0x40(%rax)
leaq 0x54(%rax), %rsi
movaps 0x2d0a9(%rip), %xmm0    # 0x446e0
movups %xmm0, 0x50(%rax)
movaps 0x2d0ae(%rip), %xmm0    # 0x446f0
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
movaps 0x2cf60(%rip), %xmm0    # 0x445d0
movups %xmm0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x18, %rcx, %rcx
addq %rax, %rcx
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rax), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
addq $0x18, %rax
cmpq %rcx, %rax
jae 0x18126
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm2
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
movsd 0x10(%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
maxsd %xmm0, %xmm1
addq $0x18, %rax
movapd %xmm1, %xmm0
jmp 0x180f1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movl 0x18(%rdi), %r8d
movq 0x28(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x30(%rdi), %rdx
cmpl $0x2, %r8d
movl $0x1, %esi
cmovgel %r8d, %esi
decl %esi
xorpd %xmm0, %xmm0
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rsi, %r8
je 0x181c9
movl (%rax,%r8,4), %r9d
imulq $0x18, %r8, %r10
testl %r9d, %r9d
cmovlel %edi, %r9d
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x181c4
movq (%rcx,%r8,8), %rbx
movslq (%rbx,%r11,4), %rbx
cmpq %rbx, %r8
jge 0x181bf
imulq $0x18, %rbx, %rbx
movsd (%rdx,%rbx), %xmm1
movsd 0x8(%rdx,%rbx), %xmm2
subsd (%rdx,%r10), %xmm1
subsd 0x8(%rdx,%r10), %xmm2
movsd 0x10(%rdx,%rbx), %xmm3
subsd 0x10(%rdx,%r10), %xmm3
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
sqrtsd %xmm3, %xmm1
addsd %xmm1, %xmm0
incq %r11
jmp 0x18168
incq %r8
jmp 0x18151
mulsd 0x2c2e7(%rip), %xmm0    # 0x444b8
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %r14
movq 0x30(%rdi), %rcx
leaq 0xa0(%rsp), %r12
leaq 0x20(%rsp), %rbp
xorl %r13d, %r13d
movslq 0x18(%r14), %rax
cmpq %rax, %r13
jge 0x1832d
movsd (%rcx), %xmm0
movsd 0x2c28f(%rip), %xmm3    # 0x444b8
mulsd %xmm3, %xmm0
addsd (%rsp), %xmm0
movsd 0x8(%rcx), %xmm1
mulsd %xmm3, %xmm1
addsd 0x8(%rsp), %xmm1
movq %rcx, 0x18(%rsp)
movsd 0x10(%rcx), %xmm2
mulsd %xmm3, %xmm2
addsd 0x10(%rsp), %xmm2
movq %r12, %rdi
leaq 0x2c7ac(%rip), %rsi     # 0x44a0b
movb $0x3, %al
callq 0x70a0
movq %rbx, %rdi
leaq 0x2c7a4(%rip), %rsi     # 0x44a14
movq %r12, %rdx
xorl %eax, %eax
callq 0x7540
xorl %r15d, %r15d
movq 0x28(%r14), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %r15
jge 0x1831c
movq 0x20(%r14), %rax
movq (%rax,%r13,8), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r13
jle 0x18314
movq 0x30(%r14), %rcx
imulq $0x18, %rax, %rax
movsd (%rcx,%rax), %xmm0
movsd 0x2c204(%rip), %xmm3    # 0x444b8
mulsd %xmm3, %xmm0
addsd (%rsp), %xmm0
movsd 0x8(%rcx,%rax), %xmm1
mulsd %xmm3, %xmm1
addsd 0x8(%rsp), %xmm1
movsd 0x10(%rcx,%rax), %xmm2
mulsd %xmm3, %xmm2
addsd 0x10(%rsp), %xmm2
movq %rbp, %rdi
leaq 0x2c724(%rip), %rsi     # 0x44a0b
movb $0x3, %al
callq 0x70a0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x7510
testl %eax, %eax
je 0x18314
movq %rbx, %rdi
leaq 0x2c71d(%rip), %rsi     # 0x44a24
movq %r12, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x7540
incq %r15
jmp 0x1827d
incq %r13
movq 0x18(%rsp), %rcx
addq $0x18, %rcx
jmp 0x18210
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_O2/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::draw_gnuplot(double, double, double, _IO_FILE*)
void voronoicell_base::draw_gnuplot(double x,double y,double z,FILE *fp) {
    int i,j,k,l,m;
    for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
        k=ed[i][j];
        if(k>=0) {
            fprintf(fp,"%g %g %g\n",x+0.5*pts[3*i],y+0.5*pts[3*i+1],z+0.5*pts[3*i+2]);
            l=i;m=j;
            do {
                ed[k][ed[l][nu[l]+m]]=-1-l;
                ed[l][m]=-1-k;
                l=k;
                fprintf(fp,"%g %g %g\n",x+0.5*pts[3*k],y+0.5*pts[3*k+1],z+0.5*pts[3*k+2]);
            } while (search_edge(l,m,k));
            fputs("\n\n",fp);
        }
    }
    reset_edges();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movapd %xmm2, %xmm3
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
movq %rdi, %r14
pushq $0x1
popq %rbp
movsd 0x2c14d(%rip), %xmm4    # 0x444b8
leaq 0x2ca2c(%rip), %r15     # 0x44d9e
leaq 0x4(%rsp), %r12
movq %rsp, %r13
movsd %xmm0, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm3, 0x10(%rsp)
movslq 0x18(%r14), %rax
cmpq %rax, %rbp
jge 0x18501
imulq $0x18, %rbp, %rax
movq %rax, 0x28(%rsp)
xorl %ecx, %ecx
movq %rbp, 0x30(%rsp)
movq 0x28(%r14), %rax
movslq (%rax,%rbp,4), %rax
cmpq %rax, %rcx
jge 0x184f9
movq 0x20(%r14), %rax
movq (%rax,%rbp,8), %rax
movl (%rax,%rcx,4), %eax
movl %eax, (%rsp)
testl %eax, %eax
js 0x184f1
movq 0x30(%r14), %rax
movq %rcx, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx), %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd 0x8(%rax,%rcx), %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
movsd 0x10(%rax,%rcx), %xmm2
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
movq %rbx, %rdi
movq %r15, %rsi
movb $0x3, %al
callq 0x7540
movq 0x8(%rsp), %rax
movl %eax, 0x4(%rsp)
movslq (%rsp), %rax
movq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
movq (%rcx,%rax,8), %rax
movslq %ebp, %rsi
notl %ebp
movq (%rcx,%rsi,8), %rcx
movslq (%rdx,%rsi,4), %rdx
movslq 0x4(%rsp), %rsi
addq %rdx, %rsi
movslq (%rcx,%rsi,4), %rdx
movl %ebp, (%rax,%rdx,4)
movl (%rsp), %eax
notl %eax
movslq 0x4(%rsp), %rdx
movl %eax, (%rcx,%rdx,4)
movslq (%rsp), %rbp
movq 0x30(%r14), %rax
imulq $0x18, %rbp, %rcx
movsd (%rax,%rcx), %xmm0
movsd 0x2c049(%rip), %xmm3    # 0x444b8
mulsd %xmm3, %xmm0
addsd 0x20(%rsp), %xmm0
movsd 0x8(%rax,%rcx), %xmm1
mulsd %xmm3, %xmm1
addsd 0x18(%rsp), %xmm1
movsd 0x10(%rax,%rcx), %xmm2
mulsd %xmm3, %xmm2
addsd 0x10(%rsp), %xmm2
movq %rbx, %rdi
movq %r15, %rsi
movb $0x3, %al
callq 0x7540
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1ea78
testb %al, %al
jne 0x1841d
leaq 0x30c7e(%rip), %rdi     # 0x49143
movq %rbx, %rsi
callq 0x73d0
movsd 0x10(%rsp), %xmm3
movsd 0x18(%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
movq 0x30(%rsp), %rbp
movsd 0x2bfcc(%rip), %xmm4    # 0x444b8
movq 0x8(%rsp), %rcx
incq %rcx
jmp 0x183a9
incq %rbp
jmp 0x1838c
movq %r14, %rdi
callq 0x1ea08
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::output_pov_mesh(double, double, double, double**, int**)
void voronoicell_base::output_pov_mesh(double x, double y, double z, double** v, int** f) {
    int i, j, k, l, m, n;
    double *ptsp = pts;
    for (i = 0; i < p; i++, ptsp += 3){
        v[i][0] = x + *ptsp*0.5; v[i][1] = y + ptsp[1] * 0.5; v[i][2] = z + ptsp[2] * 0.5;
    }
    int numf = 0;
    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);
                f[numf][0] = i; f[numf][1] = k; f[numf++][2] = m;
                k = m; l = n;
                m = ed[k][l]; ed[k][l] = -1 - m;
            }
        }
    }
    reset_edges();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x30(%rdi), %rax
movl 0x18(%rdi), %r9d
xorl %ecx, %ecx
testl %r9d, %r9d
movl $0x0, %r8d
cmovgl %r9d, %r8d
movsd 0x2bbd3(%rip), %xmm3    # 0x444b8
cmpq %rcx, %r8
je 0x1892e
movsd (%rax), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm0, %xmm4
movq (%rsi,%rcx,8), %r10
movsd %xmm4, (%r10)
movsd 0x8(%rax), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm1, %xmm4
movsd %xmm4, 0x8(%r10)
movsd 0x10(%rax), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm2, %xmm4
movsd %xmm4, 0x10(%r10)
incq %rcx
addq $0x18, %rax
jmp 0x188e5
movq 0x28(%rdi), %rax
xorl %ecx, %ecx
movabsq $0x1, %rsi
xorl %r8d, %r8d
movslq %r9d, %r9
cmpq %r9, %rsi
jge 0x18a2a
movq 0x20(%rdi), %r9
xorl %r10d, %r10d
movslq (%rax,%rsi,4), %r11
cmpq %r11, %r10
jge 0x18a1e
movq (%r9,%rsi,8), %r11
movslq (%r11,%r10,4), %r15
testq %r15, %r15
js 0x18a16
movl %r15d, %ebx
notl %ebx
movl %ebx, (%r11,%r10,4)
movslq (%rax,%rsi,4), %rbx
movslq %r10d, %r14
addq %rbx, %r14
movl (%r11,%r14,4), %r11d
movl (%rax,%r15,4), %ebp
decl %ebp
leal 0x1(%r11), %ebx
cmpl %r11d, %ebp
cmovel %ecx, %ebx
movq (%r9,%r15,8), %r14
movslq %ebx, %r12
movl (%r14,%r12,4), %r11d
movl %r11d, %ebp
notl %ebp
movl %ebp, (%r14,%r12,4)
movslq %r8d, %r14
leaq (%rdx,%r14,8), %r14
movl %r11d, %r12d
cmpq %r12, %rsi
je 0x18a16
movslq %r15d, %r15
movq (%r9,%r15,8), %r12
movslq (%rax,%r15,4), %r13
movslq %ebx, %rbx
addq %r13, %rbx
movl (%r12,%rbx,4), %r12d
movslq %r11d, %r13
movl (%rax,%r13,4), %ebp
decl %ebp
leal 0x1(%r12), %ebx
cmpl %r12d, %ebp
cmovel %ecx, %ebx
movq (%r14), %r12
movl %esi, (%r12)
movl %r15d, 0x4(%r12)
movl %r11d, 0x8(%r12)
movq (%r9,%r13,8), %r12
movslq %ebx, %r13
movl (%r12,%r13,4), %ebp
movl %r11d, %r15d
movl %ebp, %r11d
notl %ebp
movl %ebp, (%r12,%r13,4)
incl %r8d
addq $0x8, %r14
jmp 0x189b4
incq %r10
jmp 0x18954
incq %rsi
movl 0x18(%rdi), %r9d
jmp 0x18941
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ea08
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl 0x74(%rdi), %r13d
movq 0x78(%rdi), %r15
movslq %r13d, %rax
leaq 0x4(%r15), %rcx
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x18c08
cmpl %ebp, -0x4(%rcx)
je 0x18cdd
addq $0x2, %rdx
addq $0x8, %rcx
jmp 0x18bf0
cmpl 0x70(%rbx), %r13d
jne 0x18c75
leal (,%r13,2), %eax
movl %eax, 0x70(%rbx)
cmpl $0x1000001, %eax        # imm = 0x1000001
jl 0x18c3a
leaq 0x2beb1(%rip), %rdi     # 0x44ad8
pushq $0x2
popq %rsi
callq 0x1c1ae
movl 0x70(%rbx), %eax
movl 0x74(%rbx), %r13d
movq 0x78(%rbx), %r15
cltq
leaq (,%rax,4), %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, %r12
xorl %eax, %eax
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %r13d, %ecx
cmpq %rax, %rcx
je 0x18c7a
movl (%r15,%rax,4), %edx
movl %edx, (%r12,%rax,4)
incq %rax
jmp 0x18c63
movq %r15, %r12
jmp 0x18c92
testq %r15, %r15
je 0x18c8b
movq %r15, %rdi
callq 0x7470
movl 0x74(%rbx), %r13d
movq %r12, 0x78(%rbx)
movslq %r13d, %rax
incl %r13d
movl %r13d, 0x74(%rbx)
movl %ebp, (%r12,%rax,4)
movsd (%r14), %xmm0
movsd 0x2b816(%rip), %xmm1    # 0x444c0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
negl %eax
ucomisd 0x2b80b(%rip), %xmm0    # 0x444c8
pushq $0x1
popq %rcx
cmovbel %eax, %ecx
movslq 0x74(%rbx), %rax
leal 0x1(%rax), %edx
movl %edx, 0x74(%rbx)
movl %ecx, (%r12,%rax,4)
movslq 0x74(%rbx), %rax
leaq (%r12,%rax,4), %rcx
addq $-0x4, %rcx
movl (%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ee44
movq 0x30(%r14), %rax
movslq 0x18(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd 0x2b5b9(%rip), %xmm0    # 0x444b8
cmpq %rcx, %rsi
jge 0x18f38
movsd (%rax,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
movsd 0x8(%rax,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdx,%rsi,8)
movsd 0x10(%rax,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdx,%rsi,8)
addq $0x3, %rsi
jmp 0x18eff
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ee44
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
movq 0x30(%r14), %rax
movslq 0x18(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd 0x2b466(%rip), %xmm0    # 0x444b8
cmpq %rcx, %rsi
jge 0x19097
movsd (%rax,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm4, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
movsd 0x8(%rax,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
movsd %xmm1, 0x8(%rdx,%rsi,8)
movsd 0x10(%rax,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rdx,%rsi,8)
addq $0x3, %rsi
jmp 0x19052
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::face_perimeters(std::vector<double, std::allocator<double>>&)
void voronoicell_base::face_perimeters(std::vector<double> &v) {
    v.clear();
    int i,j,k,l,m;
    double dx,dy,dz,perim;
    for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
        k=ed[i][j];
        if(k>=0) {
            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];
            perim=sqrt(dx*dx+dy*dy+dz*dz);
            ed[i][j]=-1-k;
            l=cycle_up(ed[i][nu[i]+j],k);
            do {
                m=ed[k][l];
                dx=pts[3*m]-pts[3*k];
                dy=pts[3*m+1]-pts[3*k+1];
                dz=pts[3*m+2]-pts[3*k+2];
                perim+=sqrt(dx*dx+dy*dy+dz*dz);
                ed[k][l]=-1-m;
                l=cycle_up(ed[k][nu[k]+l],m);
                k=m;
            } while (k!=i);
            v.push_back(0.5*perim);
        }
    }
    reset_edges();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x191b1
movq %rax, 0x8(%r14)
pushq $0x1
popq %r12
xorl %r13d, %r13d
movq %r14, 0x8(%rsp)
movslq 0x18(%rbx), %rax
cmpq %rax, %r12
jge 0x19322
imulq $0x18, %r12, %rbp
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movslq (%rax,%r12,4), %rcx
cmpq %rcx, %r15
jge 0x1931a
movq 0x20(%rbx), %rcx
movq (%rcx,%r12,8), %rdi
movl (%rdi,%r15,4), %edx
testl %edx, %edx
js 0x19312
movq 0x30(%rbx), %rsi
imulq $0x18, %rdx, %r8
movsd (%rsi,%r8), %xmm0
movsd 0x8(%rsi,%r8), %xmm1
subsd (%rsi,%rbp), %xmm0
subsd 0x8(%rsi,%rbp), %xmm1
movsd 0x10(%rsi,%r8), %xmm2
subsd 0x10(%rsi,%rbp), %xmm2
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
sqrtsd %xmm2, %xmm0
movl %edx, %r8d
notl %r8d
movl %r8d, (%rdi,%r15,4)
movslq (%rax,%r12,4), %r8
movslq %r15d, %r9
addq %r8, %r9
movl (%rdi,%r9,4), %edi
movl (%rax,%rdx,4), %r9d
decl %r9d
leal 0x1(%rdi), %r8d
cmpl %edi, %r9d
cmovel %r13d, %r8d
movslq %edx, %r9
movq (%rcx,%r9,8), %rdi
movslq %r8d, %r8
movl (%rdi,%r8,4), %edx
movslq %edx, %r10
imulq $0x18, %r10, %r11
leal (%r9,%r9,2), %r14d
movslq %r14d, %r14
movsd (%rsi,%r11), %xmm1
movsd 0x8(%rsi,%r11), %xmm2
subsd (%rsi,%r14,8), %xmm1
subsd 0x8(%rsi,%r14,8), %xmm2
movsd 0x10(%rsi,%r11), %xmm3
subsd 0x10(%rsi,%r14,8), %xmm3
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
sqrtsd %xmm3, %xmm1
addsd %xmm1, %xmm0
movl %r10d, %r11d
notl %r11d
movl %r11d, (%rdi,%r8,4)
movslq (%rax,%r9,4), %r9
addq %r8, %r9
movl (%rdi,%r9,4), %edi
movl (%rax,%r10,4), %r9d
decl %r9d
leal 0x1(%rdi), %r8d
cmpl %edi, %r9d
cmovel %r13d, %r8d
cmpq %rdx, %r12
jne 0x19265
mulsd 0x2b1bb(%rip), %xmm0    # 0x444b8
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1f16c
incq %r15
jmp 0x191d1
incq %r12
jmp 0x191bd
movq %rbx, %rdi
callq 0x1ea08
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
andl $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 0x197ab
movl 0x18(%rdi), %ecx
sarl $0x3, %ecx
addq $0x28, %rax
pushq $0x1
popq %rdx
pushq $0x1
popq %rsi
cmpl %ecx, %edx
jge 0x1eec8
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 0x1979c
ucomisd %xmm3, %xmm5
ja 0x197ab
movl %esi, 0x1c(%rdi)
movl %esi, %r8d
movapd %xmm5, %xmm4
jmp 0x1979f
movl %esi, %r8d
incq %rsi
addl %r8d, %edx
addq $0x18, %rax
jmp 0x1975a
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x171ca
movq 0xa0(%rbx), %rax
movq 0x18(%rax), %rax
leaq 0xc(%rax), %rcx
movaps 0x2ab67(%rip), %xmm0    # 0x44710
movups %xmm0, (%rax)
leaq 0x18(%rax), %rdx
movaps 0x2ab69(%rip), %xmm0    # 0x44720
movups %xmm0, 0x10(%rax)
leaq 0x24(%rax), %rsi
movaps 0x2ab6a(%rip), %xmm0    # 0x44730
movups %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rdi
leaq 0x3c(%rax), %r8
movaps 0x2ab67(%rip), %xmm0    # 0x44740
movups %xmm0, 0x30(%rax)
leaq 0x48(%rax), %r9
movaps 0x2ab68(%rip), %xmm0    # 0x44750
movups %xmm0, 0x40(%rax)
leaq 0x54(%rax), %r10
movaps 0x2ab69(%rip), %xmm0    # 0x44760
movups %xmm0, 0x50(%rax)
movq 0xa8(%rbx), %r11
movq %rax, (%r11)
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)
movq 0xa8(%rbx), %rax
movq %r9, 0x30(%rax)
movq 0xa8(%rbx), %rax
movq %r10, 0x38(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x173b2
movq 0xa0(%rbx), %rax
movq 0x20(%rax), %rax
movaps 0x2ab01(%rip), %xmm0    # 0x44770
movups %xmm0, (%rax)
leaq 0x10(%rax), %rcx
movaps 0x2ab03(%rip), %xmm0    # 0x44780
movups %xmm0, 0x10(%rax)
leaq 0x20(%rax), %rdx
movaps 0x2ab04(%rip), %xmm0    # 0x44790
movups %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rsi
movaps 0x2ab05(%rip), %xmm0    # 0x447a0
movups %xmm0, 0x30(%rax)
leaq 0x40(%rax), %rdi
movaps 0x2ab06(%rip), %xmm0    # 0x447b0
movups %xmm0, 0x40(%rax)
leaq 0x50(%rax), %r8
movaps 0x2ab07(%rip), %xmm0    # 0x447c0
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_O2/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 0x17540
movq 0xa0(%rbx), %rax
movq 0x18(%rax), %rax
leaq 0xc(%rax), %rcx
movaps 0x2aa96(%rip), %xmm0    # 0x447d0
movups %xmm0, (%rax)
leaq 0x18(%rax), %rdx
movaps 0x2aa98(%rip), %xmm0    # 0x447e0
movups %xmm0, 0x10(%rax)
leaq 0x24(%rax), %rsi
movaps 0x2aa99(%rip), %xmm0    # 0x447f0
movups %xmm0, 0x20(%rax)
movq 0xa8(%rbx), %rdi
movq %rax, (%rdi)
movq 0xa8(%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0xa8(%rbx), %rax
movq %rdx, 0x10(%rax)
movq 0xa8(%rbx), %rax
movq %rsi, 0x18(%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16ca4
leaq 0x40df9(%rip), %rax     # 0x5acd0
movq %rax, (%rbx)
movslq 0xc(%rbx), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
pushq $-0x1
popq %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
cmpq $0x3, %r12
je 0x19f44
movq %r14, %rdi
callq 0x7030
movq 0xa0(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
addq $0x20, %r14
jmp 0x19f22
movl $0xc00, %edi            # imm = 0xC00
callq 0x7030
movq 0xa0(%rbx), %rcx
movq %rax, 0x18(%rcx)
pushq $0x4
popq %r12
movl $0x80, %r14d
cmpq %r15, %r12
jge 0x19f84
movq %r14, %rdi
callq 0x7030
movq 0xa0(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
addq $0x20, %r14
jmp 0x19f63
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x19f94
jmp 0x19f94
movq %rax, %r14
movq %rbx, %rdi
callq 0x16e1a
movq %r14, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
movsd 0x287e8(%rip), %xmm1    # 0x44490
ucomisd %xmm0, %xmm1
jbe 0x1bcb2
pushq $-0x1
jmp 0x1bcc2
ucomisd 0x287de(%rip), %xmm0    # 0x44498
jbe 0x18bcc
pushq $0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/cell.cc
// Function: void voro::voronoicell_base::add_memory_vertices<voro::voronoicell>(voro::voronoicell&)
void voronoicell_base::add_memory_vertices(vc_class &vc) {
    int i=(current_vertices<<1),j,**pp,*pnu;
    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
movq %rdi, %rbx
movl 0x8(%rdi), %r13d
leal (,%r13,2), %ebp
movq %r13, (%rsp)
cmpl $0x1000001, %ebp        # imm = 0x1000001
jl 0x1bcfd
leaq 0x28f0f(%rip), %rdi     # 0x44c00
pushq $0x2
popq %rsi
callq 0x1c1ae
movl 0x8(%rbx), %r13d
movslq %ebp, %r14
leaq (,%r14,8), %rdi
testl %ebp, %ebp
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x7030
movq %rax, %r15
movq 0x20(%rbx), %rdi
movslq %r13d, %r12
xorl %eax, %eax
cmpq %r12, %rax
jge 0x1bd34
movq (%rdi,%rax,8), %rcx
movq %rcx, (%r15,%rax,8)
incq %rax
jmp 0x1bd22
testq %rdi, %rdi
je 0x1bd45
callq 0x7470
movl 0x8(%rbx), %r13d
movslq %r13d, %r12
shlq $0x2, %r14
testl %ebp, %ebp
movq %r15, 0x20(%rbx)
pushq $-0x1
popq %r15
cmovsq %r15, %r14
movq %r14, %rdi
callq 0x7030
movq %rax, %r14
movq 0x28(%rbx), %rdi
xorl %eax, %eax
cmpq %r12, %rax
jge 0x1bd79
movl (%rdi,%rax,4), %ecx
movl %ecx, (%r14,%rax,4)
incq %rax
jmp 0x1bd68
testq %rdi, %rdi
je 0x1bd87
callq 0x7470
movl 0x8(%rbx), %r13d
movq %r14, 0x28(%rbx)
imull $0x6, (%rsp), %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x7030
movq %rax, %r14
leal (%r13,%r13,2), %eax
movq 0x30(%rbx), %rdi
cltq
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x1bdc9
movsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
jmp 0x1bdb4
testq %rdi, %rdi
je 0x1bdd3
callq 0x7470
movq %r14, 0x30(%rbx)
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop