LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, %rsi
callq 0xee46
movq (%rbx), %rdi
cmpl $0x2, %ebp
jne 0xe570
leaq 0x20(%rbx), %rsi
leaq 0x20(%rsp), %rdx
callq 0xee88
jmp 0xe575
callq 0xf2f2
cmpb $0x1, 0x68(%rbx)
jne 0xe5c2
movq 0x4ca16(%rip), %rdi     # 0x5af98
leaq 0x3069c(%rip), %rsi     # 0x3ec25
callq 0x7360
movq %rax, %rdi
movl %r15d, %esi
callq 0x7690
leaq 0x3068d(%rip), %rsi     # 0x3ec2d
movq %rax, %rdi
callq 0x7360
movq %rax, %rdi
movl %r14d, %esi
callq 0x7690
leaq 0x35d42(%rip), %rsi     # 0x442fc
movq %rax, %rdi
callq 0x7360
movq %rbx, %rdi
callq 0xe648
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
ja 0xe60e
movsd %xmm1, 0x8(%rsp)
cmpl $0x2, %ebp
jne 0xe5fa
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xe828
movsd 0x8(%rsp), %xmm1
jmp 0xe60e
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
callq 0xe992
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
seta %bl
leaq 0x20(%rsp), %rdi
callq 0xf37a
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf37a
movq %rbx, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::update_h(Eigen::SparseMatrix<double, 0, int>&)
void Diagram::update_h(Eigen::SparseMatrix<double>& pHessian) {
        Eigen::VectorXd deltaH;
        Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double>> solver;
        deltaH = solver.compute(pHessian).solve(mGradient);

        for (int i = 0; i < mNumDiracs; i++) {
            mHs[i] -= deltaH(i);
        }

        // 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
        // Liang Mi
        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 $0x158, %rsp            # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x135da
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0xf60c
leaq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0xf642
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rsp, %rdi
callq 0x1399f
xorl %r14d, %r14d
movq %rsp, %r15
movslq 0x38(%rbx), %rax
cmpq %rax, %r14
jge 0xe8af
movq %r15, %rdi
movq %r14, %rsi
callq 0xf594
movq 0x50(%rbx), %rcx
movsd (%rcx,%r14,8), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, (%rcx,%r14,8)
incq %r14
jmp 0xe882
movq (%rbx), %rdi
callq 0x21ab6
pushq $0x2
popq %r12
xorl %r14d, %r14d
movslq 0x38(%rbx), %rax
cmpq %rax, %r14
jge 0xe944
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 0x30254(%rip), %xmm0    # 0x3eb48
jb 0xe8fc
sqrtsd %xmm0, %xmm3
jmp 0xe929
movsd %xmm4, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
callq 0x72e0
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm4
movapd %xmm0, %xmm3
movq %r15, %rdi
movl %r14d, %esi
movapd %xmm4, %xmm0
callq 0x20caa
incq %r14
addq $0x6, %r12
jmp 0xe8be
leaq 0x38(%rsp), %rdi
callq 0xf690
movq (%rsp), %rdi
callq 0x7410
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xe973
movq %rax, %rbx
xorl %edi, %edi
jmp 0xe984
jmp 0xe973
jmp 0xe973
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf690
movq (%rsp), %rdi
callq 0x7410
movq %rbx, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
xorpd 0x301b4(%rip), %xmm0    # 0x3eb60
movapd %xmm0, (%rsp)
xorl %r15d, %r15d
movslq 0x38(%rbx), %rax
cmpq %rax, %r15
jge 0xea5b
movq %r14, %rdi
movq %r15, %rsi
callq 0xf5d6
movq 0x50(%rbx), %rcx
movsd (%rax), %xmm0
mulsd (%rsp), %xmm0
addsd (%rcx,%r15,8), %xmm0
movsd %xmm0, (%rcx,%r15,8)
incq %r15
ucomisd 0x30158(%rip), %xmm0    # 0x3eb48
ja 0xe9b4
movq 0x4c5e7(%rip), %rdi     # 0x5afe0
leaq 0x30282(%rip), %rsi     # 0x3ec82
callq 0x7360
leaq 0x3029c(%rip), %rsi     # 0x3eca8
movq %rax, %rdi
callq 0x7360
leaq 0x30298(%rip), %rsi     # 0x3ecb3
movq %rax, %rdi
callq 0x7360
movq %rax, %rdi
movl $0xe4, %esi
callq 0x7690
leaq 0x2fa1c(%rip), %rsi     # 0x3e453
movq %rax, %rdi
callq 0x7360
leaq 0x30274(%rip), %rsi     # 0x3ecba
movq %rax, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71c0
callq 0x7130
movq (%rbx), %rdi
callq 0x21ab6
pushq $0x2
popq %r12
xorl %r14d, %r14d
movslq 0x38(%rbx), %rax
cmpq %rax, %r14
jge 0xeaee
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 0x300a8(%rip), %xmm0    # 0x3eb48
jb 0xeaa8
sqrtsd %xmm0, %xmm3
jmp 0xead3
movsd %xmm4, (%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
callq 0x72e0
movsd 0x18(%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
movsd (%rsp), %xmm4
movapd %xmm0, %xmm3
movq %r15, %rdi
movl %r14d, %esi
movapd %xmm4, %xmm0
callq 0x20caa
incq %r14
addq $0x6, %r12
jmp 0xea6a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x3c(%rbx), %rax
cmpq %rax, %r15
jge 0xed89
movq 0x8(%rbx), %rdi
movslq 0x20(%rdi,%r14), %rax
addq %r14, %rdi
imulq $0x30, %rax, %rsi
addq 0x20(%rbx), %rsi
movsd %xmm0, 0x8(%rsp)
callq 0xf6ae
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r15
addq $0x28, %r14
jmp 0xed42
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf812
leaq 0x50(%rsp), %rdi
callq 0x19ec0
movq %r14, %rdi
callq 0xf85c
testb %al, %al
je 0xf34b
leaq 0x50(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xfa80
movq %r15, %rdi
callq 0xf8ba
testb %al, %al
jne 0xf331
leaq 0x50(%rsp), %rdi
callq 0x19fa8
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf364
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x19fa8
movq %rbx, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x1373c
leaq 0xe0(%rbx), %rdi
leaq 0x50(%rbx), %rsi
callq 0x13764
movb $0x1, (%rbx)
movw $0x101, 0x11c(%rbx)     # imm = 0x101
andl $0x0, 0x118(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0xf846
movq %r14, %rdi
callq 0xf85c
testb %al, %al
je 0xf7e2
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xf894
testb %al, %al
je 0xf7d6
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 %r12, %rdi
movq %rbx, %rsi
callq 0x18340
movq %r14, %rdi
callq 0xf8ba
testb %al, %al
jne 0xf78a
leaq 0x8(%rsp), %rdi
callq 0x16e1a
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xf7fd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x16e1a
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
js 0xfbf7
movq %rdx, %rbx
testq %rdx, %rdx
js 0xfbf7
movq %rsi, %r14
movq %rdi, %r15
cmpq %rsi, 0x10(%rdi)
jle 0xfbf7
cmpq %rbx, 0x8(%r15)
jle 0xfbf7
movq 0x18(%r15), %rax
movq 0x20(%r15), %rcx
movslq (%rax,%rbx,4), %rsi
testq %rcx, %rcx
je 0xfb9a
movl (%rcx,%rbx,4), %eax
addl %esi, %eax
jmp 0xfb9e
movl 0x4(%rax,%rbx,4), %eax
cmpl %esi, %eax
jl 0xfc16
cmpl %esi, %eax
jle 0xfbe0
movslq %eax, %r13
leaq 0x28(%r15), %r12
leaq -0x1(%r13), %rdx
movslq %r14d, %rcx
movq %r12, %rdi
callq 0x11678
cmpq %r13, %rax
jge 0xfbe0
movq 0x30(%r15), %rcx
movslq (%rcx,%rax,4), %rcx
cmpq %r14, %rcx
jne 0xfbe0
shlq $0x3, %rax
addq (%r12), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11378
leaq 0x306f9(%rip), %rdi     # 0x402f7
leaq 0x2f21f(%rip), %rsi     # 0x3ee24
leaq 0x30718(%rip), %rcx     # 0x40324
movl $0xd0, %edx
callq 0x7270
leaq 0x30779(%rip), %rdi     # 0x40396
leaq 0x2f200(%rip), %rsi     # 0x3ee24
leaq 0x306f9(%rip), %rcx     # 0x40324
movl $0xd7, %edx
callq 0x7270
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 0, int>::SparseMatrix<Eigen::Transpose<Eigen::SparseMatrix<double, 0, int>>>(Eigen::SparseMatrixBase<Eigen::Transpose<Eigen::SparseMatrix<double, 0, int>>> const&)
inline SparseMatrix(const SparseMatrixBase<OtherDerived>& other)
      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
    {
      EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
      check_template_parameters();
      const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
      if (needToTranspose)
        *this = other.derived();
      else
      {
        #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
          EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
        #endif
        internal::call_assignment_no_alias(*this, other.derived());
      }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
callq 0x11dda
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x1060a
movq %r14, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 1, int>::insertBackUncompressed(long, long)
EIGEN_STRONG_INLINE Scalar& insertBackUncompressed(Index row, Index col)
    {
      const Index outer = IsRowMajor ? row : col;
      const Index inner = IsRowMajor ? col : row;

      eigen_assert(!isCompressed());
      eigen_assert(m_innerNonZeros[outer]<=(m_outerIndex[outer+1] - m_outerIndex[outer]));

      Index p = m_outerIndex[outer] + m_innerNonZeros[outer]++;
      m_data.index(p) = convert_index(inner);
      return (m_data.value(p) = 0);
    }

// Assembly:
pushq %rax
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x10181
movl (%rax,%rsi,4), %ecx
movq 0x18(%rdi), %r9
movl (%r9,%rsi,4), %r8d
movl 0x4(%r9,%rsi,4), %r9d
subl %r8d, %r9d
cmpl %r9d, %ecx
jg 0x101a0
leal 0x1(%rcx), %r9d
movl %r9d, (%rax,%rsi,4)
addl %ecx, %r8d
movslq %r8d, %rax
movq 0x30(%rdi), %rcx
movl %edx, (%rcx,%rax,4)
movq 0x28(%rdi), %rcx
leaq (%rcx,%rax,8), %rax
andq $0x0, (%rax)
popq %rcx
retq
leaq 0x2f7c7(%rip), %rdi     # 0x3f94f
leaq 0x2ec95(%rip), %rsi     # 0x3ee24
leaq 0x2f7c9(%rip), %rcx     # 0x3f95f
movl $0x37b, %edx            # imm = 0x37B
callq 0x7270
leaq 0x2f839(%rip), %rdi     # 0x3f9e0
leaq 0x2ec76(%rip), %rsi     # 0x3ee24
leaq 0x2f7aa(%rip), %rcx     # 0x3f95f
movl $0x37c, %edx            # imm = 0x37C
callq 0x7270
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq %rdx, 0x10(%rdi)
andq $0x0, 0x38(%rdi)
movq %rsi, %r14
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
sete %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x105d9
movq 0x18(%rbx), %rdi
callq 0x7410
leaq 0x4(,%r14,4), %rdi
callq 0x74b0
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x105d5
callq 0x1062c
movq %r14, 0x8(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x105f0
callq 0x7410
andq $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 0x7200
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jge 0x10c89
cvtsi2sd %rbx, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %r15
addq %rbx, %r15
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r15
cmovgeq %rax, %r15
cmpq %rbx, %r15
jge 0x10c7e
callq 0x1062c
movq %r14, %rdi
movq %r15, %rsi
callq 0x10c94
movq %rbx, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/CompressedStorage.h
// Function: Eigen::internal::CompressedStorage<double, int>::reallocate(long)
inline void reallocate(Index size)
    {
      #ifdef EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
        EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
      #endif
      eigen_internal_assert(size!=m_allocatedSize);
      internal::scoped_array<Scalar> newValues(size);
      internal::scoped_array<StorageIndex> newIndices(size);
      Index copySize = (std::min)(size, m_size);
      if (copySize>0) {
        internal::smart_copy(m_values, m_values+copySize, newValues.ptr());
        internal::smart_copy(m_indices, m_indices+copySize, newIndices.ptr());
      }
      std::swap(m_values,newValues.ptr());
      std::swap(m_indices,newIndices.ptr());
      m_allocatedSize = size;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
callq 0x10d42
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x10d68
movq 0x10(%r14), %r15
cmpq %rbx, %r15
cmovgeq %rbx, %r15
testq %r15, %r15
jle 0x10cf1
movq (%r14), %rsi
movq (%rsp), %rdi
leaq (,%r15,8), %rdx
callq 0x7300
movq 0x8(%r14), %rsi
movq 0x8(%rsp), %rdi
shlq $0x2, %r15
movq %r15, %rdx
callq 0x7300
movq (%r14), %rax
movq %rsp, %r15
movq (%r15), %rcx
movq %rcx, (%r14)
movq %rax, (%r15)
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rdi
movq (%rdi), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rdi)
movq %rbx, 0x18(%r14)
callq 0x10d8e
movq %r15, %rdi
callq 0x10d9c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x10d9c
movq %rbx, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseCompressedBase.h
// Function: Eigen::SparseCompressedBase<Eigen::Block<Eigen::SparseMatrix<double, 0, int>, -1, 1, true>>::InnerIterator::InnerIterator(Eigen::SparseCompressedBase<Eigen::Block<Eigen::SparseMatrix<double, 0, int>, -1, 1, true>> const&, long)
InnerIterator(const SparseCompressedBase& mat, Index outer)
      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer)
    {
      if(Derived::IsVectorAtCompileTime && mat.outerIndexPtr()==0)
      {
        m_id = 0;
        m_end = mat.nonZeros();
      }
      else
      {
        m_id = mat.outerIndexPtr()[outer];
        if(mat.isCompressed())
          m_end = mat.outerIndexPtr()[outer+1];
        else
          m_end = m_id + mat.innerNonZeroPtr()[outer];
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movups 0x28(%rax), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
movq %rdx, %rsi
callq 0x10950
movq 0x8(%r15), %rax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x11148
movq 0x10(%r15), %rdx
leaq (%rcx,%rdx,4), %rdx
movslq (%rdx,%r14,4), %rcx
movq %rcx, 0x18(%rbx)
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x11157
movq 0x10(%r15), %rdx
leaq (%rax,%rdx,4), %rax
movslq (%rax,%r14,4), %rax
addq %rcx, %rax
jmp 0x1115c
andq $0x0, 0x18(%rbx)
movq %r15, %rdi
callq 0x11166
jmp 0x1115c
movslq 0x4(%rdx,%r14,4), %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseCompressedBase.h
// Function: Eigen::SparseCompressedBase<Eigen::SparseMatrix<double, 0, int>>::nonZeros() const
inline Index nonZeros() const
    {
      if(Derived::IsVectorAtCompileTime && outerIndexPtr()==0)
        return derived().nonZeros();
      else if(isCompressed())
        return outerIndexPtr()[derived().outerSize()]-outerIndexPtr()[0];
      else if(derived().outerSize()==0)
        return 0;
      else
        return innerNonZeros().sum();
    }

// Assembly:
movq %rdi, %rsi
cmpq $0x0, 0x20(%rdi)
je 0x116d5
cmpq $0x0, 0x8(%rsi)
je 0x116e8
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x11ac0
movq %rbx, %rdi
callq 0x111d2
cltq
addq $0x20, %rsp
popq %rbx
retq
movq 0x8(%rsi), %rax
movq 0x18(%rsi), %rcx
movslq (%rcx,%rax,4), %rax
movslq (%rcx), %rcx
subq %rcx, %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/CompressedStorage.h
// Function: Eigen::internal::CompressedStorage<double, int>::searchLowerIndex(long, long, long) const
inline Index searchLowerIndex(Index start, Index end, Index key) const
    {
      while(end>start)
      {
        Index mid = (end+start)>>1;
        if (m_indices[mid]<key)
          start = mid+1;
        else
          end = mid;
      }
      return start;
    }

// Assembly:
movq %rsi, %rax
movq 0x8(%rdi), %rsi
cmpq %rax, %rdx
jle 0x116a1
leaq (%rax,%rdx), %rdi
sarq %rdi
movslq (%rsi,%rdi,4), %r8
cmpq %rcx, %r8
jl 0x11699
movq %rdi, %rdx
jmp 0x1167f
incq %rdi
movq %rdi, %rax
jmp 0x1167f
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/CompressedStorage.h
// Function: Eigen::internal::CompressedStorage<double, int>::append(double const&, long)
void append(const Scalar& v, Index i)
    {
      Index id = m_size;
      resize(m_size+1, 1);
      m_values[id] = v;
      m_indices[id] = internal::convert_index<StorageIndex>(i);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %r12
leaq 0x1(%r12), %rsi
movsd 0x2d44a(%rip), %xmm0    # 0x3eb58
callq 0x10c46
movsd (%r14), %xmm0
movq (%r15), %rax
movsd %xmm0, (%rax,%r12,8)
movq 0x8(%r15), %rax
movl %ebx, (%rax,%r12,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12014
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x12012
callq 0x7410
andq $0x0, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 0, int>::setZero()
inline void setZero()
    {
      m_data.clear();
      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
      if(m_innerNonZeros)
        memset(m_innerNonZeros, 0, (m_outerSize)*sizeof(StorageIndex));
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x38(%rdi)
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rdi
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x7200
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x122cd
movq 0x8(%rbx), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
popq %rbx
jmp 0x7200
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 0, int>::insertBackByOuterInner(long, long)
inline Scalar& insertBackByOuterInner(Index outer, Index inner)
    {
      eigen_assert(Index(m_outerIndex[outer+1]) == m_data.size() && "Invalid ordered insertion (invalid outer index)");
      eigen_assert( (m_outerIndex[outer+1]-m_outerIndex[outer]==0 || m_data.index(m_data.size()-1)<inner) && "Invalid ordered insertion (invalid inner index)");
      Index p = m_outerIndex[outer+1];
      ++m_outerIndex[outer+1];
      m_data.append(Scalar(0), inner);
      return m_data.value(p);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
movslq 0x4(%rax,%rsi,4), %r14
cmpq %r14, 0x38(%rdi)
jne 0x123e7
movq %rdi, %rbx
cmpl (%rax,%rsi,4), %r14d
je 0x123bc
movq 0x30(%rbx), %rcx
movslq -0x4(%rcx,%r14,4), %rcx
cmpq %rdx, %rcx
jge 0x12406
leaq 0x28(%rbx), %rdi
leal 0x1(%r14), %ecx
movl %ecx, 0x4(%rax,%rsi,4)
movq %rsp, %rsi
andq $0x0, (%rsi)
callq 0x116ec
shlq $0x3, %r14
addq 0x28(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2e755(%rip), %rdi     # 0x40b43
leaq 0x2ca2f(%rip), %rsi     # 0x3ee24
leaq 0x2e7aa(%rip), %rcx     # 0x40ba6
movl $0x188, %edx            # imm = 0x188
callq 0x7270
leaq 0x2e819(%rip), %rdi     # 0x40c26
leaq 0x2ca10(%rip), %rsi     # 0x3ee24
leaq 0x2e78b(%rip), %rcx     # 0x40ba6
movl $0x189, %edx            # imm = 0x189
callq 0x7270
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 0, int>::operator=(Eigen::SparseMatrix<double, 0, int> const&)
inline SparseMatrix& operator=(const SparseMatrix& other)
    {
      if (other.isRValue())
      {
        swap(other.const_cast_derived());
      }
      else if(this!=&other)
      {
        #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
          EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
        #endif
        initAssignment(other);
        if(other.isCompressed())
        {
          internal::smart_copy(other.m_outerIndex, other.m_outerIndex + m_outerSize + 1, m_outerIndex);
          m_data = other.m_data;
        }
        else
        {
          Base::operator=(other);
        }
      }
      return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x12536
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10e24
jmp 0x12588
cmpq %r14, %rbx
je 0x12588
movq %rbx, %rdi
movq %r14, %rsi
callq 0x125c8
cmpq $0x0, 0x20(%r14)
je 0x1255a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12648
jmp 0x12588
movq 0x18(%r14), %rsi
movq 0x8(%rbx), %rax
leaq (%rsi,%rax,4), %rdx
addq $0x4, %rdx
subq %rsi, %rdx
je 0x12578
movq 0x18(%rbx), %rdi
callq 0x7300
addq $0x28, %r14
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x125ee
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/CompressedStorage.h
// Function: Eigen::internal::CompressedStorage<double, int>::operator=(Eigen::internal::CompressedStorage<double, int> const&)
CompressedStorage& operator=(const CompressedStorage& other)
    {
      resize(other.size());
      if(other.size()>0)
      {
        internal::smart_copy(other.m_values,  other.m_values  + m_size, m_values);
        internal::smart_copy(other.m_indices, other.m_indices + m_size, m_indices);
      }
      return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
xorps %xmm0, %xmm0
callq 0x10c46
cmpq $0x0, 0x10(%r14)
jle 0x1263d
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x1263d
movq (%r14), %rsi
movq (%rbx), %rdi
shlq $0x3, %rdx
callq 0x7300
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x1263d
movq 0x8(%r14), %rsi
movq 0x8(%rbx), %rdi
shlq $0x2, %rdx
callq 0x7300
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x18(%rsi)
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
je 0x136dc
movq %r14, %rdi
callq 0x116a2
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movdqu 0x28(%r14), %xmm0
movb $0x0, (%rbx)
movq %r15, 0x8(%rbx)
movq %r12, 0x10(%rbx)
jmp 0x13703
imulq %r12, %r15
movq %r14, %rdi
callq 0x116a2
movdqu 0x28(%r14), %xmm0
movb $0x0, (%rbx)
movq $0x1, 0x8(%rbx)
movq %r15, 0x10(%rbx)
leaq 0x18(%rbx), %rdx
xorl %ecx, %ecx
andl $0x0, 0x18(%rbx)
movl %eax, 0x1c(%rbx)
movq %rdx, 0x20(%rbx)
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x28(%rbx)
movq %rcx, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/../../include/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
// Function: Eigen::LeastSquareDiagonalPreconditioner<double>& Eigen::LeastSquareDiagonalPreconditioner<double>::factorize<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>>>(Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const&)
LeastSquareDiagonalPreconditioner& factorize(const MatType& mat)
    {
      // Compute the inverse squared-norm of each column of mat
      m_invdiag.resize(mat.cols());
      if(MatType::IsRowMajor)
      {
        m_invdiag.setZero();
        for(Index j=0; j<mat.outerSize(); ++j)
        {
          for(typename MatType::InnerIterator it(mat,j); it; ++it)
            m_invdiag(it.index()) += numext::abs2(it.value());
        }
        for(Index j=0; j<mat.cols(); ++j)
          if(numext::real(m_invdiag(j))>RealScalar(0))
            m_invdiag(j) = RealScalar(1)/numext::real(m_invdiag(j));
      }
      else
      {
        for(Index j=0; j<mat.outerSize(); ++j)
        {
          RealScalar sum = mat.col(j).squaredNorm();
          if(sum>RealScalar(0))
            m_invdiag(j) = RealScalar(1)/sum;
          else
            m_invdiag(j) = RealScalar(1);
        }
      }
      Base::m_isInitialized = true;
      return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x137f6
xorl %r15d, %r15d
leaq 0x18(%rsp), %r12
cmpq 0x8(%r14), %r15
jge 0x137e3
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1384c
movq %r12, %rdi
callq 0x13826
movsd 0x2b3ae(%rip), %xmm2    # 0x3eb58
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
xorpd %xmm3, %xmm3
cmpltsd %xmm0, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm3
orpd %xmm1, %xmm3
movapd %xmm3, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf594
movaps (%rsp), %xmm0
movlps %xmm0, (%rax)
incq %r15
jmp 0x13786
movb $0x1, 0x10(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq 0xf8(%rdi), %rcx
addq %rax, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
leaq 0x110(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x110(%rdi)
movsd 0x100(%rdi), %xmm0
leaq 0x108(%rdi), %rax
movq %rax, 0x8(%rsp)
movsd %xmm0, 0x108(%rdi)
leaq 0x50(%rdi), %rbp
leaq 0xe0(%rdi), %r14
movb $0x1, %al
xorl %r13d, %r13d
leaq 0x60(%rsp), %r15
leaq 0x28(%rsp), %r12
testb $0x1, %al
je 0x13b0d
movq 0x58(%rbx), %rax
movq 0xf8(%rbx), %rcx
addq %rax, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
movq %rax, 0x110(%rbx)
movsd 0x100(%rbx), %xmm0
movsd %xmm0, 0x108(%rbx)
movq %r15, %rdi
movq 0x20(%rsp), %rsi
movq %r13, %rdx
callq 0x13b9a
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq %r13, %rdx
callq 0x15b9e
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x13bc7
xorl %eax, %eax
pushq $0x1
popq %r13
jmp 0x13a9a
movb $0x1, (%rbx)
movsd 0x100(%rbx), %xmm0
xorl %eax, %eax
ucomisd 0x108(%rbx), %xmm0
setb %al
addl %eax, %eax
movl %eax, 0x118(%rbx)
addq $0x98, %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/../../include/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
// Function: Eigen::Solve<Eigen::DiagonalPreconditioner<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1>> const Eigen::DiagonalPreconditioner<double>::solve<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const&) const
inline const Solve<DiagonalPreconditioner, Rhs>
    solve(const MatrixBase<Rhs>& b) const
    {
      eigen_assert(m_isInitialized && "DiagonalPreconditioner is not initialized.");
      eigen_assert(m_invdiag.size()==b.rows()
                && "DiagonalPreconditioner::solve(): invalid number of rows of the right hand side matrix b");
      return Solve<DiagonalPreconditioner, Rhs>(*this, b.derived());
    }

// Assembly:
pushq %rax
cmpb $0x0, 0x10(%rdi)
je 0x141a9
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x141c2
movq %rdi, %rax
movq %rsi, %rdx
popq %rcx
retq
leaq 0x2e87b(%rip), %rdi     # 0x42a2b
leaq 0x2e8b4(%rip), %rsi     # 0x42a6b
leaq 0x2e8f3(%rip), %rcx     # 0x42ab1
pushq $0x61
jmp 0x141d9
leaq 0x2e99d(%rip), %rdi     # 0x42b66
leaq 0x2e89b(%rip), %rsi     # 0x42a6b
leaq 0x2e8da(%rip), %rcx     # 0x42ab1
pushq $0x63
popq %rdx
callq 0x7270
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movb $0x1, %al
xorl %r13d, %r13d
testb $0x1, %al
je 0x14686
xorl %ebp, %ebp
cmpq 0x8(%r12), %rbp
jge 0x1467b
movsd (%rbx), %xmm0
movq 0x30(%r15), %rax
imulq %r13, %rax
shlq $0x3, %rax
addq (%r15), %rax
mulsd (%rax,%rbp,8), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x14696
movsd 0x8(%rsp), %xmm1
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq 0x8(%r14), %rdi
imulq %r13, %rdi
shlq $0x3, %rdi
addq (%r14), %rdi
cmpq %rax, %rcx
jge 0x14673
movslq (%rsi,%rcx,4), %r8
movsd (%rdx,%rcx,8), %xmm0
mulsd %xmm1, %xmm0
addsd (%rdi,%r8,8), %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %rcx
movq %rcx, 0x28(%rsp)
jmp 0x1464b
incq %rbp
jmp 0x145e9
xorl %eax, %eax
pushq $0x1
popq %r13
jmp 0x145df
addq $0x38, %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/../../include/Eigen/src/SparseCore/SparseDenseProduct.h
// Function: Eigen::internal::sparse_time_dense_product_impl<Eigen::Transpose<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, double, 1, true>::run(Eigen::Transpose<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double const&)
static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
  {
    LhsEval lhsEval(lhs);
    
    Index n = lhs.outerSize();
#ifdef EIGEN_HAS_OPENMP
    Eigen::initParallel();
    Index threads = Eigen::nbThreads();
#endif
    
    for(Index c=0; c<rhs.cols(); ++c)
    {
#ifdef EIGEN_HAS_OPENMP
      // This 20000 threshold has been found experimentally on 2D and 3D Poisson problems.
      // It basically represents the minimal amount of work to be done to be worth it.
      if(threads>1 && lhsEval.nonZerosEstimate() > 20000)
      {
        #pragma omp parallel for schedule(dynamic,(n+threads*4-1)/(threads*4)) num_threads(threads)
        for(Index i=0; i<n; ++i)
          processRow(lhsEval,rhs,res,alpha,i,c);
      }
      else
#endif
      {
        for(Index i=0; i<n; ++i)
          processRow(lhsEval,rhs,res,alpha,i,c);
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x8(%rdi), %rax
movq %rsp, %rcx
movq %rax, 0x8(%rcx)
andq $0x0, 0x10(%rcx)
movq %rsi, %r12
movq 0x8(%rax), %r15
xorl %r13d, %r13d
testq %r15, %r15
cmovleq %r13, %r15
movb $0x1, %al
testb $0x1, %al
je 0x14872
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x1486a
movq %rsp, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %rbp, %r8
movq %r13, %r9
callq 0x14882
incq %rbp
jmp 0x14849
xorl %eax, %eax
pushq $0x1
popq %r13
jmp 0x14843
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/../../include/Eigen/src/SparseCore/SparseDenseProduct.h
// Function: Eigen::internal::sparse_time_dense_product_impl<Eigen::Transpose<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, double, 1, true>::processRow(Eigen::internal::evaluator<Eigen::Transpose<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const>> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double const&, long, long)
static void processRow(const LhsEval& lhsEval, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha, Index i, Index col)
  {
    typename Res::Scalar tmp(0);
    for(LhsInnerIterator it(lhsEval,i); it ;++it)
      tmp += it.value() * rhs.coeff(it.index(),col);
    res.coeffRef(i,col) += alpha * tmp;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rsi
movq %rsp, %rbp
movq %rbp, %rdi
movq %r8, %rdx
callq 0x14920
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rcx
movq (%rbp), %rdx
movq 0x8(%rbp), %rsi
movq 0x8(%r13), %rdi
imulq %rbx, %rdi
shlq $0x3, %rdi
addq (%r13), %rdi
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
jge 0x148f1
movsd (%rdx,%rcx,8), %xmm1
movslq (%rsi,%rcx,4), %r8
mulsd (%rdi,%r8,8), %xmm1
addsd %xmm1, %xmm0
incq %rcx
jmp 0x148d4
imulq 0x8(%r12), %rbx
shlq $0x3, %rbx
addq (%r12), %rbx
mulsd (%r15), %xmm0
addsd (%rbx,%r14,8), %xmm0
movsd %xmm0, (%rbx,%r14,8)
addq $0x28, %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/../../include/Eigen/src/SparseCore/SparseDenseProduct.h
// Function: void Eigen::internal::generic_product_impl<Eigen::Transpose<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, -1, 1, true>, Eigen::SparseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Transpose<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const> const&, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, -1, 1, true> const&, double const&)
static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
  {
    typedef typename nested_eval<Lhs,((Rhs::Flags&RowMajorBit)==0) ? 1 : Rhs::ColsAtCompileTime>::type LhsNested;
    typedef typename nested_eval<Rhs,((Lhs::Flags&RowMajorBit)==0) ? 1 : Dynamic>::type RhsNested;
    LhsNested lhsNested(lhs);
    RhsNested rhsNested(rhs);
    internal::sparse_time_dense_product(lhsNested, rhsNested, dst, alpha);
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, %rax
movups (%rsi), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movups (%rdx), %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movups 0x18(%rdx), %xmm0
movups %xmm0, 0x18(%rsi)
movq 0x30(%rdx), %rdx
movq %rdx, 0x30(%rsi)
movq %rax, %rdx
callq 0x14c2e
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x45309(%rip), %rdi     # 0x5af98
leaq 0x2e652(%rip), %rsi     # 0x442e8
callq 0x7360
movq %rax, %rdi
callq 0x71c0
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x74d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15d22
leaq 0x28(%rsp), %rdi
callq 0x77f8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x74d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16318
leaq 0x8(%rsp), %rdi
callq 0x77f8
movq 0x452a4(%rip), %rdi     # 0x5af98
callq 0x71c0
movq %rbx, %rdi
callq 0x166d6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x15d0f
movq %rax, %rbx
movq %r14, %rdi
callq 0x77f8
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/ot.cc
// Function: vot::OT::check_total_mass()
void OT::check_total_mass() {
        double totalDirac = mDiagram->total_dirac_mass();
        double totalEmpirical = mDiagram->total_empirical_mass();
        if (mFlagVerbose) {
            std::cout << "--> Checking total measures... " << std::endl;
            std::cout << "       Total Dirac measure: " << totalDirac << std::endl;
            std::cout << "       Total Empirical measure: " << totalEmpirical << std::endl;
            std::cout << "       Diff: " << fabs(totalDirac - totalEmpirical) << std::endl;
            std::cout << std::endl;
        }
        ASSERT_VOT(fabs(totalDirac - totalEmpirical) / totalDirac < otTOLERANCE*1000,
               "Total Dirac: " << totalDirac << " not equal to total Empirical: " << totalEmpirical);
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xe4d6
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
callq 0xe4fe
cmpb $0x0, 0x28(%rbx)
movsd %xmm0, 0x8(%rsp)
je 0x167b2
movq 0x4488e(%rip), %rbx     # 0x5af98
leaq 0x2dc79(%rip), %rsi     # 0x4438a
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
callq 0x71c0
leaq 0x2dc82(%rip), %rsi     # 0x443aa
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x7610
movq %rax, %rdi
callq 0x71c0
leaq 0x2dc7b(%rip), %rsi     # 0x443c7
movq %rbx, %rdi
callq 0x7360
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x7610
movq %rax, %rdi
callq 0x71c0
leaq 0x2dc77(%rip), %rsi     # 0x443e8
movq %rbx, %rdi
callq 0x7360
movsd (%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
andpd 0x283e4(%rip), %xmm0    # 0x3eb70
movapd %xmm0, 0x10(%rsp)
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x71c0
movapd 0x10(%rsp), %xmm1
jmp 0x167c3
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
andpd 0x283ad(%rip), %xmm1    # 0x3eb70
divsd (%rsp), %xmm1
movsd 0x2db10(%rip), %xmm0    # 0x442e0
ucomisd %xmm1, %xmm0
jbe 0x167dc
addq $0x20, %rsp
popq %rbx
retq
movq 0x447fd(%rip), %rdi     # 0x5afe0
leaq 0x2dc0c(%rip), %rsi     # 0x443f6
callq 0x7360
leaq 0x2db18(%rip), %rsi     # 0x4430e
movq %rax, %rdi
callq 0x7360
leaq 0x284ae(%rip), %rsi     # 0x3ecb3
movq %rax, %rdi
callq 0x7360
pushq $0x5e
popq %rsi
movq %rax, %rdi
callq 0x7690
leaq 0x27c34(%rip), %rsi     # 0x3e453
movq %rax, %rdi
callq 0x7360
leaq 0x2dc25(%rip), %rsi     # 0x44453
movq %rax, %rdi
callq 0x7360
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x7750
leaq 0x2dc17(%rip), %rsi     # 0x44461
movq %rax, %rdi
callq 0x7360
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x7750
movq %rax, %rdi
callq 0x71c0
callq 0x7130
nop