LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::Diagram(vot::otBBox, int)
Diagram::Diagram(const otBBox bBox, const int numBlocks) {
        mDiagram = new voro::container_poly(bBox.xMin, bBox.xMax,
                                             bBox.yMin, bBox.yMax,
                                             bBox.zMin, bBox.zMax,
                                             numBlocks, numBlocks, numBlocks,
                                             false, false, false, 8);
        mNumEmpiricals = 0;
        mNumDiracs = 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq $0x0, 0x60(%rdi)
movl $0x198, %edi            # imm = 0x198
callq 0x7380
movq %rax, %r15
leaq 0x30(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x18(%rax), %xmm3
movsd 0x20(%rax), %xmm4
movsd 0x28(%rax), %xmm5
movq %r15, %rdi
movl %ebp, %esi
movl %ebp, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x8
pushq $0x0
callq 0x27e32
addq $0x10, %rsp
movq %r15, (%rbx)
movq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x198, %esi            # imm = 0x198
movq %r15, %rdi
callq 0x7390
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x10a4e
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x7390
jmp 0x10a4e
movq %rax, %r14
leaq 0x8(%rbx), %r15
movq 0x40(%rbx), %rdi
callq 0x7430
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x10a70
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x7390
movq (%r15), %rdi
testq %rdi, %rdi
je 0x10a84
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x7390
movq %r14, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::add_dirac(double, double, double, double, double, double, bool)
void Diagram::add_dirac(double x, double y, double z, double d, double m, double h, bool fix) {
        mDiagram->put(mNumDiracs, x, y, z, sqrt(h)); // Add a centroid/particle in container
        mDiracs.push_back(Dirac(x,y,z,d,m,fix));
        mHs.push_back(h);
        mNumDiracs++;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movsd %xmm5, 0x30(%rsp)
movq (%rdi), %r14
movl 0x38(%rdi), %r15d
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
movsd %xmm5, 0x28(%rsp)
jb 0x10ae6
xorps %xmm3, %xmm3
sqrtsd %xmm5, %xmm3
jmp 0x10af3
movapd %xmm5, %xmm0
callq 0x72e0
movapd %xmm0, %xmm3
movq %r14, %rdi
movl %r15d, %esi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x27fc2
movsd (%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movb %bpl, 0x60(%rsp)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x10b7a
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, 0x28(%rbx)
jmp 0x10b88
leaq 0x20(%rbx), %rdi
leaq 0x38(%rsp), %rdx
callq 0x176c2
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
movsd 0x28(%rsp), %xmm0
je 0x10ba6
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x58(%rbx)
jmp 0x10bb4
leaq 0x50(%rbx), %rdi
leaq 0x30(%rsp), %rdx
callq 0x17868
incl 0x38(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::write_dirac(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Diagram::write_dirac(std::string pFilename) {
        std::cout << "--> Writing resulting Diract measures to a " << pFilename << std::endl;
        std::ofstream outP(pFilename);
        for (int i = 0; i < mNumDiracs; i++) {
            // Index starts from 0
            outP << mDiracs[i].x() << " " << mDiracs[i].y() << " "
                 << mDiracs[i].z() << " "  << mDiracs[i].dirac() << " "
                 << mDiracs[i].mass() << " "  << mHs[i] << std::endl;
        }
        outP.close();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
movq 0x5000e(%rip), %r15     # 0x60f98
leaq 0x39c90(%rip), %rsi     # 0x4ac21
movl $0x2b, %edx
movq %r15, %rdi
callq 0x73f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x73f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x7350
movsbl %al, %esi
movq %r15, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7270
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x77a0
cmpl $0x0, 0x38(%rbx)
jle 0x11110
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
leaq 0x3ea5e(%rip), %r15     # 0x4fa60
xorl %ebp, %ebp
movq 0x20(%rbx), %rax
movsd (%rax,%r13), %xmm0
movq %r14, %rdi
callq 0x7620
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73f0
movq 0x20(%rbx), %rax
movsd 0x8(%rax,%r13), %xmm0
movq %r12, %rdi
callq 0x7620
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73f0
movq 0x20(%rbx), %rax
movsd 0x10(%rax,%r13), %xmm0
movq %r12, %rdi
callq 0x7620
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73f0
movq 0x20(%rbx), %rax
movsd 0x18(%rax,%r13), %xmm0
movq %r12, %rdi
callq 0x7620
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73f0
movq 0x20(%rbx), %rax
movsd 0x20(%rax,%r13), %xmm0
movq %r12, %rdi
callq 0x7620
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73f0
movq 0x50(%rbx), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r12, %rdi
callq 0x7620
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x7350
movsbl %al, %esi
movq %r12, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7270
incq %rbp
movslq 0x38(%rbx), %rax
addq $0x30, %r13
cmpq %rax, %rbp
jl 0x11004
leaq 0x8(%rsp), %rdi
callq 0x7540
movq 0x4fe4f(%rip), %rax     # 0x60f70
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x7310
leaq 0x100(%rsp), %rdi
callq 0x7130
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11160
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7580
movq %rbx, %rdi
callq 0x76d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::total_dirac_mass()
double Diagram::total_dirac_mass() {
        double total = 0;
        for (int i = 0; i < mNumDiracs; i++) {
            total += mDiracs[i].dirac();
        }
        return total;
    }

// Assembly:
movslq 0x38(%rdi), %rcx
testq %rcx, %rcx
jle 0x12481
movq 0x20(%rdi), %rax
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
addsd 0x18(%rax,%rdx), %xmm0
addq $0x30, %rdx
cmpq %rdx, %rcx
jne 0x12471
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::total_empirical_mass()
double Diagram::total_empirical_mass() {
        double total = 0;
        for (int i = 0; i < mNumEmpiricals; i++) {
            total += mEmpiricals[i].mass();
        }
        return total;
    }

// Assembly:
movslq 0x3c(%rdi), %rcx
testq %rcx, %rcx
jle 0x124b1
movq 0x8(%rdi), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
addsd 0x18(%rax,%rdx), %xmm0
addq $0x28, %rdx
cmpq %rdx, %rcx
jne 0x124a1
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::update(int, double, double, int, int)
bool Diagram::update(int method, double thres, double step, int iterP, int iterH) {
        // Hessian is computed during updating the diagram
        Eigen::SparseMatrix<double> hessian(mNumDiracs, mNumDiracs);
        if (method == METHOD_NEWTON)
            mDiagram->update_diagram(mDiracs, hessian);
        else 
            mDiagram->update_diagram();

        // Return true if gradient doesn't change too much.
        if (mFlagVerbose) 
            std::cout << "iterP: " << iterP << ", iterH: " << iterH << ". ";
        
        if (compute_gradient() < thres) {
            return true;
        }

        if (method == METHOD_NEWTON)
            update_h(hessian);
        else
            update_h(step);

        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x38(%rdi), %rdx
leaq 0x20(%rsp), %rdi
movb $0x0, (%rdi)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rdi)
movupd %xmm0, 0x18(%rdi)
movupd %xmm0, 0x28(%rdi)
movupd %xmm0, 0x38(%rdi)
movq %rdx, %rsi
callq 0x165c6
movq (%rbx), %rdi
cmpl $0x2, %ebp
jne 0x1251b
leaq 0x20(%rbx), %rsi
leaq 0x20(%rsp), %rdx
callq 0x131be
jmp 0x12520
callq 0x1398a
cmpb $0x1, 0x68(%rbx)
jne 0x12583
movq 0x4ea6b(%rip), %rdi     # 0x60f98
leaq 0x38741(%rip), %rsi     # 0x4ac75
movl $0x7, %edx
callq 0x73f0
movq 0x4ea53(%rip), %rdi     # 0x60f98
movl %r15d, %esi
callq 0x76a0
movq %rax, %r15
leaq 0x38726(%rip), %rsi     # 0x4ac7d
movl $0x9, %edx
movq %rax, %rdi
callq 0x73f0
movq %r15, %rdi
movl %r14d, %esi
callq 0x76a0
leaq 0x3cc96(%rip), %rsi     # 0x4f20c
movl $0x2, %edx
movq %rax, %rdi
callq 0x73f0
movq %rbx, %rdi
callq 0x1262c
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x125cf
movsd %xmm1, 0x8(%rsp)
cmpl $0x2, %ebp
jne 0x125bb
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x12a52
movsd 0x8(%rsp), %xmm1
jmp 0x125cf
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x12c8a
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
seta %bl
leaq 0x48(%rsp), %r14
movq -0x10(%r14), %rdi
callq 0x7430
movq -0x8(%r14), %rdi
callq 0x7430
movq %r14, %rdi
callq 0x14eb6
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x14eb6
jmp 0x12624
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x13afc
movq %rbx, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::update_h(double)
void Diagram::update_h(double step) {
        for (int i = 0; i < mNumDiracs; i++) {
            mHs[i] -= step * mGradient[i]; // delta h
            ASSERT_VOT(mHs[i] > 0, "Negative h not allowed");
        }
        // I haven't found a way to directly update h
        // The alternative is to clear the diagram and define a new one with new h
        mDiagram->clear();
        for (int i = 0; i < mNumDiracs; i++) {
            mDiagram->put(i, mDiracs[i].x(), mDiracs[i].y(), mDiracs[i].z(), sqrt(mHs[i]));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x38(%rdi), %rax
testq %rax, %rax
jle 0x12cf0
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rdx
movq 0x50(%rbx), %rsi
xorpd 0x37ebb(%rip), %xmm0    # 0x4ab70
xorl %edi, %edi
testq %rdx, %rdx
cmovleq %rdi, %rdx
xorpd %xmm1, %xmm1
cmpq %rdi, %rdx
je 0x12d9d
movsd (%rcx,%rdi,8), %xmm2
mulsd %xmm0, %xmm2
addsd (%rsi,%rdi,8), %xmm2
movsd %xmm2, (%rsi,%rdi,8)
ucomisd %xmm1, %xmm2
jbe 0x12dbc
incq %rdi
cmpq %rdi, %rax
jne 0x12cc2
movq (%rbx), %rdi
callq 0x28e2c
cmpl $0x0, 0x38(%rbx)
jle 0x12d91
movl $0x2, %r12d
xorl %r14d, %r14d
movq (%rbx), %r15
movq 0x20(%rbx), %rax
movsd -0x10(%rax,%r12,8), %xmm4
movsd -0x8(%rax,%r12,8), %xmm1
movsd (%rax,%r12,8), %xmm2
movq 0x50(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd 0x37e20(%rip), %xmm0    # 0x4ab58
jb 0x12d43
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x12d6e
movsd %xmm4, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x72e0
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm4
movapd %xmm0, %xmm3
movq %r15, %rdi
movl %r14d, %esi
movapd %xmm4, %xmm0
callq 0x27fc2
incq %r14
movslq 0x38(%rbx), %rax
addq $0x6, %r12
cmpq %rax, %r14
jl 0x12d0b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x387d0(%rip), %rdi     # 0x4b574
leaq 0x387e6(%rip), %rsi     # 0x4b591
leaq 0x39f22(%rip), %rcx     # 0x4ccd4
movl $0x198, %edx            # imm = 0x198
callq 0x7240
movq 0x4e21d(%rip), %rdi     # 0x60fe0
leaq 0x37f08(%rip), %rsi     # 0x4acd2
callq 0x7360
leaq 0x37f22(%rip), %rsi     # 0x4acf8
movq %rax, %rdi
callq 0x7360
leaq 0x37f1e(%rip), %rsi     # 0x4ad03
movq %rax, %rdi
callq 0x7360
movq %rax, %rdi
movl $0xe4, %esi
callq 0x76a0
leaq 0x37662(%rip), %rsi     # 0x4a463
movq %rax, %rdi
callq 0x7360
leaq 0x37efa(%rip), %rsi     # 0x4ad0a
movq %rax, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71a0
callq 0x7110
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::compute_wasserstein()
double Diagram::compute_wasserstein() {
        double wd = 0;
        for (int i = 0; i < mNumEmpiricals; i++) {
            wd += mEmpiricals[i].costL2(mDiracs[mEmpiricals[i].cellIndex()]);
        }
        return wd;
    }

// Assembly:
movslq 0x3c(%rdi), %rdx
testq %rdx, %rdx
jle 0x131ba
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %rcx
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movslq 0x20(%rax,%rsi), %rdi
leaq (%rdi,%rdi,2), %rdi
shlq $0x4, %rdi
movsd (%rax,%rsi), %xmm1
movsd 0x8(%rax,%rsi), %xmm2
subsd (%rcx,%rdi), %xmm1
subsd 0x8(%rcx,%rdi), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
movsd 0x10(%rax,%rsi), %xmm2
subsd 0x10(%rcx,%rdi), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
mulsd 0x18(%rax,%rsi), %xmm2
addsd %xmm2, %xmm0
addq $0x28, %rsi
cmpq %rsi, %rdx
jne 0x13163
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/./container.hh
// Function: voro::container_poly::update_diagram()
inline void update_diagram() {
            c_loop_all vl(*this);
            voronoicell_neighbor c;
            if (vl.start()) {
                do {
                    compute_cell(c, vl);
                } while (vl.inc());
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %r14
movl (%rdi), %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rdi), %ebx
movq 0xb8(%rdi), %r12
leaq 0x28(%rsp), %rdi
callq 0x1f642
movq %r14, %rdi
xorl %ecx, %ecx
cmpl $0x0, (%r12)
movl $0x0, %r15d
movl $0x0, %r9d
movl $0x0, %ebp
movl $0x0, %r14d
jne 0x13a2e
movq %rbx, %rdx
leal -0x1(%rbx), %eax
xorl %r9d, %r9d
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %r12, %rsi
movq %r15, %r8
incl %r14d
cmpl 0x8(%rsp), %r14d
jne 0x13a1c
incl %ebp
cmpl 0xc(%rsp), %ebp
jne 0x13a19
cmpl %r8d, %eax
je 0x13aca
incl %r9d
xorl %ebp, %ebp
xorl %r14d, %r14d
leaq 0x1(%r8), %r15
cmpl $0x0, 0x4(%rsi,%r8,4)
je 0x139f6
movq %rsi, %r12
movq %rdx, %rbx
addq $0xf8, %rdi
movq %r12, 0x18(%rsp)
leaq 0x4(%r12), %rax
movq %rax, 0x10(%rsp)
decl %ebx
movq %rbx, 0x20(%rsp)
movq %r9, %r13
movl %r9d, (%rsp)
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
movl %r15d, %edx
movl %ecx, %r12d
movl %r14d, %r8d
movl %ebp, %r9d
callq 0x33e3c
incl %r12d
movslq %r15d, %rax
movq 0x18(%rsp), %rcx
cmpl (%rcx,%rax,4), %r12d
movq %rbx, %rdi
movl %r12d, %ecx
movq %r13, %r9
jl 0x13a4b
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movl 0x8(%rsp), %ecx
incl %r14d
cmpl %ecx, %r14d
jne 0x13aba
incl %ebp
cmpl 0xc(%rsp), %ebp
jne 0x13ab7
cmpl %r15d, 0x20(%rsp)
je 0x13aca
incl %r9d
xorl %ebp, %ebp
xorl %r14d, %r14d
movl 0x8(%rsp), %ecx
jmp 0x13aba
xorl %r14d, %r14d
incl %r15d
cmpl $0x0, (%rax)
leaq 0x4(%rax), %rax
je 0x13a92
xorl %ecx, %ecx
jmp 0x13a4b
leaq 0x28(%rsp), %rdi
callq 0x1f736
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1f736
movq %rbx, %rdi
callq 0x76d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/../../include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
// Function: Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double, 0, int>, Eigen::LeastSquareDiagonalPreconditioner<double>>& Eigen::IterativeSolverBase<Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double, 0, int>, Eigen::LeastSquareDiagonalPreconditioner<double>>>::compute<Eigen::SparseMatrix<double, 0, int>>(Eigen::EigenBase<Eigen::SparseMatrix<double, 0, int>> const&)
Derived& compute(const EigenBase<MatrixDerived>& A)
  {
    grab(A.derived());
    m_preconditioner.compute(matrix());
    m_isInitialized = true;
    m_analysisIsOk = true;
    m_factorizationIsOk = true;
    m_info = m_preconditioner.info();
    return derived();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rdi), %r15
movq %r15, %rdi
callq 0x17e6c
xorl %eax, %eax
movb %al, 0x50(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x78(%r14)
movq $0x0, 0x88(%r14)
movb %al, 0xd8(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x17d42
leaq 0xe0(%r14), %rdi
movq %r15, %rsi
callq 0x17e9a
movb $0x1, (%r14)
movw $0x101, 0x11c(%r14)     # imm = 0x101
movl $0x0, 0x118(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/./container.hh
// Function: void voro::container_poly::draw_diagram_gnuplot<voro::c_loop_all>(voro::c_loop_all&, _IO_FILE*)
void draw_diagram_gnuplot(c_loop &vl, FILE *fp) {
            voronoicell c; double *pp;
            if (vl.start()) do if (compute_cell(c, vl)) {
                pp = p[vl.ijk] + ps*vl.q;
                c.draw_gnuplot(*pp, pp[1], pp[2], fp);
            } while (vl.inc());
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x1ba74
leaq 0x4cdb1(%rip), %rax     # 0x60c48
movq %rax, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movl $0x0, 0x40(%r14)
movq 0x28(%r14), %rsi
xorl %ecx, %ecx
cmpl $0x0, (%rsi)
movl $0x0, %eax
movl $0x0, %r9d
movl $0x0, %r8d
movl $0x0, %edx
jne 0x13f37
movl (%r14), %edi
movl 0x4(%r14), %r10d
movl 0x10(%r14), %r11d
decl %r11d
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq %rdx, %r12
incl %edx
movl %edx, 0x3c(%r14)
incl %r8d
movl %r8d, 0x30(%r14)
cmpl %edi, %r8d
jne 0x13f2a
movl $0x0, 0x30(%r14)
incl %r9d
movl %r9d, 0x34(%r14)
cmpl %r10d, %r9d
jne 0x13f27
movl $0x0, 0x34(%r14)
incl %eax
movl %eax, 0x38(%r14)
cmpl %r12d, %r11d
je 0x14028
xorl %r9d, %r9d
xorl %r8d, %r8d
leaq 0x1(%r12), %rdx
cmpl $0x0, 0x4(%rsi,%r12,4)
je 0x13ee4
leaq 0xf8(%r15), %r12
leaq 0x10(%rsp), %r13
movl %eax, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x30424
testb %al, %al
je 0x13f8f
movq 0xb0(%r15), %rax
movslq 0x3c(%r14), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc8(%r15), %rcx
movslq 0x40(%r14), %rdx
imulq %rcx, %rdx
movsd (%rax,%rdx,8), %xmm0
movsd 0x8(%rax,%rdx,8), %xmm1
movsd 0x10(%rax,%rdx,8), %xmm2
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1d3cc
movl 0x40(%r14), %ecx
incl %ecx
movl %ecx, 0x40(%r14)
movq 0x28(%r14), %r10
movl 0x3c(%r14), %edx
movslq %edx, %r11
movl 0x30(%r14), %r8d
movl 0x34(%r14), %r9d
movl 0x38(%r14), %eax
cmpl (%r10,%r11,4), %ecx
jl 0x13f43
movl $0x0, 0x40(%r14)
movl (%r14), %ecx
movl 0x4(%r14), %esi
movl 0x10(%r14), %edi
leaq (%r10,%r11,4), %r10
addq $0x4, %r10
decl %edi
movl %edx, %r11d
leal 0x1(%r11), %edx
movl %edx, 0x3c(%r14)
incl %r8d
movl %r8d, 0x30(%r14)
cmpl %ecx, %r8d
jne 0x14017
movl $0x0, 0x30(%r14)
incl %r9d
movl %r9d, 0x34(%r14)
cmpl %esi, %r9d
jne 0x14014
movl $0x0, 0x34(%r14)
incl %eax
movl %eax, 0x38(%r14)
cmpl %r11d, %edi
je 0x14028
xorl %r9d, %r9d
xorl %r8d, %r8d
cmpl $0x0, (%r10)
leaq 0x4(%r10), %r10
je 0x13fd3
xorl %ecx, %ecx
jmp 0x13f43
leaq 0x10(%rsp), %rdi
callq 0x1bc00
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1bc00
movq %rbx, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 0, int>::coeffRef(long, long)
inline Scalar& coeffRef(Index row, Index col)
    {
      eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
      
      const Index outer = IsRowMajor ? row : col;
      const Index inner = IsRowMajor ? col : row;

      Index start = m_outerIndex[outer];
      Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
      eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix");
      if(end<=start)
        return insert(row,col);
      const Index p = m_data.searchLowerIndex(start,end-1,StorageIndex(inner));
      if((p<end) && (m_data.index(p)==inner))
        return m_data.value(p);
      else
        return insert(row,col);
    }

// Assembly:
pushq %rbx
testq %rsi, %rsi
js 0x14285
testq %rdx, %rdx
js 0x14285
cmpq %rsi, 0x10(%rdi)
jle 0x14285
cmpq %rdx, 0x8(%rdi)
jle 0x14285
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r8
movslq (%rcx,%rdx,4), %rax
testq %r8, %r8
je 0x14224
movl (%r8,%rdx,4), %ecx
addl %eax, %ecx
jmp 0x14228
movl 0x4(%rcx,%rdx,4), %ecx
cmpl %eax, %ecx
jl 0x142a4
cmpl %eax, %ecx
jle 0x1427f
movslq %ecx, %rcx
leaq -0x1(%rcx), %r8
cmpq %rax, %r8
jle 0x14263
movslq %esi, %r9
movq 0x30(%rdi), %r10
leaq (%r8,%rax), %r11
sarq %r11
movslq (%r10,%r11,4), %rbx
cmpq %rbx, %r9
jg 0x14258
movq %r11, %r8
jmp 0x1425e
incq %r11
movq %r11, %rax
cmpq %rax, %r8
jg 0x14243
cmpq %rcx, %rax
jge 0x1427f
movq 0x30(%rdi), %rcx
movslq (%rcx,%rax,4), %rcx
cmpq %rsi, %rcx
jne 0x1427f
shlq $0x3, %rax
addq 0x28(%rdi), %rax
popq %rbx
retq
popq %rbx
jmp 0x1565a
leaq 0x37ac8(%rip), %rdi     # 0x4bd54
leaq 0x36be1(%rip), %rsi     # 0x4ae74
leaq 0x37ae7(%rip), %rcx     # 0x4bd81
movl $0xd0, %edx
callq 0x7240
leaq 0x37b48(%rip), %rdi     # 0x4bdf3
leaq 0x36bc2(%rip), %rsi     # 0x4ae74
leaq 0x37ac8(%rip), %rcx     # 0x4bd81
movl $0xd7, %edx
callq 0x7240
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 1, int>::resize(long, long)
void resize(Index rows, Index cols)
    {
      const Index outerSize = IsRowMajor ? rows : cols;
      m_innerSize = IsRowMajor ? cols : rows;
      m_data.clear();
      if (m_outerSize != outerSize || m_outerSize==0)
      {
        std::free(m_outerIndex);
        m_outerIndex = static_cast<StorageIndex*>(std::malloc((outerSize + 1) * sizeof(StorageIndex)));
        if (!m_outerIndex) internal::throw_std_bad_alloc();
        
        m_outerSize = outerSize;
      }
      if(m_innerNonZeros)
      {
        std::free(m_innerNonZeros);
        m_innerNonZeros = 0;
      }
      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x10(%rdi)
movq $0x0, 0x38(%rdi)
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
sete %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x14e53
movq 0x18(%rbx), %rdi
callq 0x7430
leaq 0x4(,%r14,4), %rdi
callq 0x74c0
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x14e87
movq %r14, 0x8(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x14e6d
callq 0x7430
movq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %r14
movq 0x18(%rbx), %rdi
leaq 0x4(,%r14,4), %rdx
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x71e0
movl $0x8, %edi
callq 0x71b0
movq 0x4c0e8(%rip), %rcx     # 0x60f80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x4c0fa(%rip), %rsi     # 0x60fa0
movq 0x4c0ab(%rip), %rdx     # 0x60f58
movq %rax, %rdi
callq 0x7690
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/CompressedStorage.h
// Function: Eigen::internal::CompressedStorage<double, int>::resize(long, double)
void resize(Index size, double reserveSizeFactor = 0)
    {
      if (m_allocatedSize<size)
      {
        Index realloc_size = (std::min<Index>)(NumTraits<StorageIndex>::highest(),  size + Index(reserveSizeFactor*double(size)));
        if(realloc_size<size)
          internal::throw_std_bad_alloc();
        reallocate(realloc_size);
      }
      m_size = size;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jge 0x1543f
cvtsi2sd %rbx, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %r13
addq %rbx, %r13
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r13
cmovgeq %rax, %r13
cmpq %rbx, %r13
jl 0x15452
movq %r13, %rax
shrq $0x3d, %rax
leaq (,%r13,8), %rcx
xorl %r15d, %r15d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movq %rax, %rbp
movq %r13, %rax
shrq $0x3e, %rax
leaq (,%r13,4), %rcx
negq %rax
sbbq %r15, %r15
orq %rcx, %r15
movq %r15, %rdi
callq 0x7030
movq %rax, %r12
movq (%r14), %rsi
movq 0x10(%r14), %r15
cmpq %r13, %r15
cmovgeq %r13, %r15
testq %r15, %r15
movq %rsi, 0x10(%rsp)
jle 0x15411
leaq (,%r15,8), %rdx
movq %rbp, %rdi
callq 0x7300
movq %rbp, 0x8(%rsp)
movq 0x8(%r14), %rbp
shlq $0x2, %r15
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x7300
movq 0x8(%rsp), %rcx
jmp 0x15418
movq %rbp, %rcx
movq 0x8(%r14), %rbp
movq %rcx, (%r14)
movq %r12, 0x8(%r14)
movq %r13, 0x18(%r14)
testq %rbp, %rbp
je 0x15430
movq %rbp, %rdi
callq 0x7490
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1543f
callq 0x7490
movq %rbx, 0x10(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x71b0
movq 0x4bb1d(%rip), %rcx     # 0x60f80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x4bb2f(%rip), %rsi     # 0x60fa0
movq 0x4bae0(%rip), %rdx     # 0x60f58
movq %rax, %rdi
callq 0x7690
movq %rax, %rbx
movq %rbp, %rdi
callq 0x7490
movq %rbx, %rdi
callq 0x76d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: void Eigen::SparseMatrix<double, 0, int>::initAssignment<Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::SparseMatrix<double, 0, int> const, Eigen::SparseMatrix<double, 0, int> const>>(Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::SparseMatrix<double, 0, int> const, Eigen::SparseMatrix<double, 0, int> const> const&)
void initAssignment(const Other& other)
    {
      resize(other.rows(), other.cols());
      if(m_innerNonZeros)
      {
        std::free(m_innerNonZeros);
        m_innerNonZeros = 0;
      }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rsi
callq 0x165c6
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x165c3
callq 0x7430
movq $0x0, 0x20(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseRef.h
// Function: void Eigen::internal::SparseRefBase<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>>>::construct<Eigen::SparseMatrix<double, 0, int> const>(Eigen::SparseMatrix<double, 0, int> const&)
void construct(Expression& expr)
  {
    if(expr.outerIndexPtr()==0)
      ::new (static_cast<Base*>(this)) Base(expr.size(), expr.nonZeros(), expr.innerIndexPtr(), expr.valuePtr());
    else
      ::new (static_cast<Base*>(this)) Base(expr.rows(), expr.cols(), expr.nonZeros(), expr.outerIndexPtr(), expr.innerIndexPtr(), expr.valuePtr(), expr.innerNonZeroPtr());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rcx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
testq %rcx, %rcx
je 0x17dab
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x17de5
testq %r15, %r15
je 0x17def
movq %rdx, 0x10(%rsp)
movq %r15, 0x18(%rsp)
js 0x17e4d
leaq 0x28(%rsp), %rdi
movq %rdx, (%rdi)
movq %r15, 0x10(%rdi)
leaq 0x10(%rsp), %rax
movq %rax, 0x18(%rdi)
leaq 0xf(%rsp), %rsi
callq 0x15556
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
jmp 0x17df1
testq %r15, %r15
je 0x17e04
movq 0x20(%r14), %rax
movq %rax, 0x10(%rsp)
movq %r15, 0x18(%rsp)
js 0x17e4d
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %r15, 0x10(%rdi)
leaq 0x10(%rsp), %rax
movq %rax, 0x18(%rdi)
leaq 0xf(%rsp), %rsi
callq 0x15556
jmp 0x17e06
movl (%rcx,%r15,4), %eax
subl (%rcx), %eax
xorl %edx, %edx
jmp 0x17df1
xorl %eax, %eax
movdqu 0x28(%r14), %xmm0
movb $0x0, (%rbx)
movq %r15, 0x8(%rbx)
movq %r12, 0x10(%rbx)
jmp 0x17e25
xorl %eax, %eax
imulq %r12, %r15
movdqu 0x28(%r14), %xmm0
movb $0x0, (%rbx)
movq $0x1, 0x8(%rbx)
movq %r15, 0x10(%rbx)
leaq 0x18(%rbx), %rcx
xorl %edx, %edx
movl $0x0, 0x18(%rbx)
movl %eax, 0x1c(%rbx)
movq %rcx, 0x20(%rbx)
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x28(%rbx)
movq %rdx, 0x38(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x33a00(%rip), %rdi     # 0x4b854
leaq 0x33a06(%rip), %rsi     # 0x4b861
leaq 0x33ded(%rip), %rcx     # 0x4bc4f
movl $0xa3, %edx
callq 0x7240
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseRedux.h
// Function: Eigen::SparseMatrixBase<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Block<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const>>::sum() const
typename internal::traits<Derived>::Scalar
SparseMatrixBase<Derived>::sum() const
{
  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
  Scalar res(0);
  internal::evaluator<Derived> thisEval(derived());
  for (Index j=0; j<outerSize(); ++j)
    for (typename internal::evaluator<Derived>::InnerIterator iter(thisEval,j); iter; ++iter)
      res += iter.value();
  return res;
}

// Assembly:
pushq %rax
movq 0x10(%rdi), %r8
movq 0x10(%r8), %rax
testq %rax, %rax
jle 0x18019
movq 0x18(%rdi), %rdx
movq 0x20(%r8), %rsi
movslq (%rsi,%rdx,4), %rcx
movq 0x38(%r8), %rdi
testq %rdi, %rdi
je 0x17fca
movslq (%rdi,%rdx,4), %rdx
addq %rcx, %rdx
jmp 0x17fcf
movslq 0x4(%rsi,%rdx,4), %rdx
movq 0x30(%r8), %rsi
movq 0x28(%r8), %rdi
cmpq %rcx, %rdx
jle 0x17ff0
cmpl $0x0, (%rdi,%rcx,4)
jns 0x17ff0
incq %rcx
cmpq %rcx, %rdx
jne 0x17fdc
xorpd %xmm0, %xmm0
jmp 0x18017
xorpd %xmm0, %xmm0
cmpq %rdx, %rcx
jge 0x18017
movslq (%rdi,%rcx,4), %r8
cmpq %r8, %rax
jle 0x18017
movsd (%rsi,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rdx
jne 0x17ff9
popq %rax
retq
leaq 0x33af2(%rip), %rdi     # 0x4bb12
leaq 0x33b2c(%rip), %rsi     # 0x4bb53
leaq 0x34d9f(%rip), %rcx     # 0x4cdcd
movl $0x13, %edx
callq 0x7240
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/../../include/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
// Function: void Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double, 0, int>, Eigen::LeastSquareDiagonalPreconditioner<double>>::_solve_with_guess_impl<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&) const
void _solve_with_guess_impl(const Rhs& b, Dest& x) const
  {
    m_iterations = Base::maxIterations();
    m_error = Base::m_tolerance;

    for(Index j=0; j<b.cols(); ++j)
    {
      m_iterations = Base::maxIterations();
      m_error = Base::m_tolerance;

      typename Dest::ColXpr xj(x,j);
      internal::least_square_conjugate_gradient(matrix(), b.col(j), xj, Base::m_preconditioner, m_iterations, m_error);
    }

    m_isInitialized = true;
    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
  }

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq 0xf8(%rdi), %rcx
addq %rax, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
movsd 0x100(%rdi), %xmm0
movq %rax, 0x110(%rdi)
movsd %xmm0, 0x108(%rdi)
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rcx, %rcx
sete %cl
testq %rax, %rax
setns %dil
orb %cl, %dil
je 0x18233
movq %rdx, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rax, 0x30(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
testq %rax, %rax
sete %al
testq %rdx, %rdx
setns %cl
orb %al, %cl
je 0x1824a
leaq 0x110(%rbx), %r8
leaq 0x108(%rbx), %r9
leaq 0xe0(%rbx), %rcx
leaq 0x50(%rbx), %rdi
leaq 0x38(%rsp), %rax
movq %rsi, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq %rdx, 0x30(%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0x18269
movb $0x1, (%rbx)
movsd 0x100(%rbx), %xmm0
xorl %eax, %eax
ucomisd 0x108(%rbx), %xmm0
setb %al
addl %eax, %eax
movl %eax, 0x118(%rbx)
addq $0x70, %rsp
popq %rbx
retq
leaq 0x34ee9(%rip), %rdi     # 0x4d123
leaq 0x33620(%rip), %rsi     # 0x4b861
leaq 0x34f85(%rip), %rcx     # 0x4d1cd
jmp 0x1825f
leaq 0x34ed2(%rip), %rdi     # 0x4d123
leaq 0x33609(%rip), %rsi     # 0x4b861
leaq 0x36dc4(%rip), %rcx     # 0x4f023
movl $0xaf, %edx
callq 0x7240
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseDenseProduct.h
// Function: Eigen::internal::sparse_time_dense_product_impl<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, true>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, double, 0, true>::run(Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const&, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, true> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double const&)
static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
  {
    evaluator<Lhs> lhsEval(lhs);
    for(Index c=0; c<rhs.cols(); ++c)
    {
      for(Index j=0; j<lhs.outerSize(); ++j)
      {
//        typename Res::Scalar rhs_j = alpha * rhs.coeff(j,c);
        typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j,c));
        for(LhsInnerIterator it(lhsEval,j); it ;++it)
          res.coeffRef(it.index(),c) += it.value() * rhs_j;
      }
    }
  }

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x191c6
pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %r8
movq (%rsi), %rsi
movq 0x30(%rdi), %r9
movq 0x28(%rdi), %r10
movq 0x38(%rdi), %rdi
movq (%rdx), %rdx
xorl %r11d, %r11d
movslq (%r8,%r11,4), %rbx
testq %rdi, %rdi
je 0x19183
movslq (%rdi,%r11,4), %r14
addq %rbx, %r14
jmp 0x19188
movslq 0x4(%r8,%r11,4), %r14
cmpq %rbx, %r14
jle 0x191b9
movsd (%rcx), %xmm0
mulsd (%rsi,%r11,8), %xmm0
movslq (%r10,%rbx,4), %r15
movsd (%r9,%rbx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%r15,8), %xmm1
movsd %xmm1, (%rdx,%r15,8)
incq %rbx
cmpq %rbx, %r14
jne 0x19197
incq %r11
cmpq %rax, %r11
jne 0x19171
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/icemiliang[P]vot/src/vot/ot.cc
// Function: vot::OT::import_data(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void OT::import_data(std::string pDiracFile, std::string pEmpiricalFile) {
        std::cout << "--> Importing data... " << std::endl;
        read_dirac_from_file(pDiracFile);
        read_empirical_from_file(pEmpiricalFile);
        std::cout << std::endl;
        check_total_mass();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x47397(%rip), %r14     # 0x60f98
leaq 0x355f0(%rip), %rsi     # 0x4f1f8
movl $0x16, %edx
movq %r14, %rdi
callq 0x73f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7350
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7270
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xac3a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19d26
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x19c80
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7390
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0xac3a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1acc8
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x19cbf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7390
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7350
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7270
movq %rbx, %rdi
callq 0x1b536
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x19d0d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x19d1e
movq (%r13), %rsi
incq %rsi
callq 0x7390
movq %rbx, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq (%rdi), %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xac3a
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x11176
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b86c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7390
cmpl $0x0, 0x2c(%rbx)
jle 0x1b90e
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq %rsp, %r14
cmpl $0x0, 0x30(%rbx)
jle 0x1b8b8
movl $0x1, %r15d
leal -0x1(%r15), %ecx
movq (%rbx), %rdi
movl 0x48(%rbx), %esi
movsd 0x38(%rbx), %xmm0
movsd 0x40(%rbx), %xmm1
movl %ebp, %edx
callq 0x124b6
testb %al, %al
jne 0x1b8b8
leal 0x1(%r15), %eax
cmpl 0x30(%rbx), %r15d
movl %eax, %r15d
jl 0x1b88c
movq (%rbx), %rdi
callq 0x12e26
testb %al, %al
jne 0x1b90e
incl %ebp
movq (%rbx), %r15
movq %r12, (%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xac3a
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x11176
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1b905
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7390
cmpl 0x2c(%rbx), %ebp
jl 0x1b880
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x1b92c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1b93d
movq (%r12), %rsi
incq %rsi
callq 0x7390
movq %rbx, %rdi
callq 0x76d0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x14(%rdi), %eax
addl %eax, %eax
movl %eax, 0x14(%rdi)
cmpl $0x1000001, %eax        # imm = 0x1000001
jge 0x1b9d9
movq %rsi, %r14
movq %rdi, %rbx
movslq %eax, %r12
leaq (,%r12,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, %r15
movq 0x60(%rbx), %rdi
movq (%r14), %rax
movq %r15, %r13
cmpq %rax, %rdi
jae 0x1b9ae
movq %rdi, %rcx
movq %r15, %r13
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r13)
addq $0x4, %r13
cmpq %rax, %rcx
jb 0x1b99b
testq %rdi, %rdi
je 0x1b9bc
callq 0x7490
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
callq 0x79b6
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x10(%rdi), %eax
addl %eax, %eax
movl %eax, 0x10(%rdi)
cmpl $0x1000001, %eax        # imm = 0x1000001
jge 0x1ba6f
movq %rsi, %r14
movq %rdi, %rbx
movslq %eax, %r12
leaq (,%r12,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, %r15
movq 0x50(%rbx), %rdi
movq (%r14), %rax
movq %r15, %r13
cmpq %rax, %rdi
jae 0x1ba44
movq %rdi, %rcx
movq %r15, %r13
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r13)
addq $0x4, %r13
cmpq %rax, %rcx
jb 0x1ba31
testq %rdi, %rdi
je 0x1ba52
callq 0x7490
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
callq 0x79de
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45212(%rip), %rax     # 0x60c98
movq %rax, (%rdi)
movaps 0x33910(%rip), %xmm0    # 0x4f3a0
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 0x1bb36
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 0x1bbf3
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 0x1bbac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4508a(%rip), %rax     # 0x60c98
movq %rax, (%rdi)
movslq 0xc(%rdi), %r14
testq %r14, %r14
jle 0x1bc45
incq %r14
movq 0x38(%rbx), %rax
cmpl $0x0, -0x8(%rax,%r14,4)
jle 0x1bc3c
movq 0x48(%rbx), %rax
movq -0x10(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1bc3c
callq 0x7490
decq %r14
cmpq $0x1, %r14
ja 0x1bc1d
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1bc53
callq 0x7490
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x1bc61
callq 0x7490
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1bc6f
callq 0x7490
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1bc7d
callq 0x7490
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x1bc8b
callq 0x7490
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1bc99
callq 0x7490
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1bca7
callq 0x7490
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1bcb5
callq 0x7490
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x1bcca
popq %rbx
popq %r14
jmp 0x7490
popq %rbx
popq %r14
retq