LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2a070
movq -0x20(%rbp), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x27380
movq -0x10(%rbp), %rdi
callq 0x2a0a0
cmpq $0x0, %rax
jne 0x29e2e
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x2a0d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x29ea9
movq -0x10(%rbp), %rdi
callq 0x2a0a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x2a1b0
testb $0x1, %al
jne 0x29e59
jmp 0x29e78
movq -0x10(%rbp), %rdi
callq 0x2a0a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movslq 0x4(%rcx,%rdx,4), %rcx
movq %rcx, 0x20(%rax)
jmp 0x29ea7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a1e0
movq -0x28(%rbp), %rcx
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
jmp 0x29ea9
addq $0x30, %rsp
popq %rbp
retq
nop
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 0, int>::swap(Eigen::SparseMatrix<double, 0, int>&)
inline void swap(SparseMatrix& other)
    {
      //EIGEN_DBG_SPARSE(std::cout << "SparseMatrix:: swap\n");
      std::swap(m_outerIndex, other.m_outerIndex);
      std::swap(m_innerSize, other.m_innerSize);
      std::swap(m_outerSize, other.m_outerSize);
      std::swap(m_innerNonZeros, other.m_innerNonZeros);
      m_data.swap(other.m_data);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x27fc0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x29a50
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x29a50
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x27fc0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x29a90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/CompressedStorage.h
// Function: Eigen::internal::CompressedStorage<double, int>::swap(Eigen::internal::CompressedStorage<double, int>&)
void swap(CompressedStorage& other)
    {
      std::swap(m_values, other.m_values);
      std::swap(m_indices, other.m_indices);
      std::swap(m_size, other.m_size);
      std::swap(m_allocatedSize, other.m_allocatedSize);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x28460
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x27fc0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x29a50
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x29a50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseCompressedBase.h
// Function: Eigen::SparseCompressedBase<Eigen::Block<Eigen::SparseMatrix<double, 0, int>, -1, 1, true>>::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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2a0a0
cmpq $0x0, %rax
jne 0x2a109
movq -0x30(%rbp), %rdi
callq 0x29d30
movq %rax, %rdi
callq 0x2a0d0
movq %rax, -0x8(%rbp)
jmp 0x2a199
movq -0x30(%rbp), %rdi
callq 0x2a1b0
testb $0x1, %al
jne 0x2a118
jmp 0x2a15c
movq -0x30(%rbp), %rdi
callq 0x2a0a0
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x29d30
movq %rax, %rdi
callq 0x29d70
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
callq 0x2a0a0
movq %rax, %rcx
movl -0x34(%rbp), %eax
subl (%rcx), %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x2a199
movq -0x30(%rbp), %rdi
callq 0x29d30
movq %rax, %rdi
callq 0x29d70
cmpq $0x0, %rax
jne 0x2a17d
movq $0x0, -0x8(%rbp)
jmp 0x2a199
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2a330
leaq -0x28(%rbp), %rdi
callq 0x2a3c0
cltq
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jle 0x2b953
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x10(%rbp), %rcx
sarq %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
cmpq -0x20(%rbp), %rax
jge 0x2b949
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2b951
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x2b90c
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rdi), %rsi
addq $0x1, %rsi
movsd 0x622e4(%rip), %xmm0    # 0x8ddb8
callq 0x27ee0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
leaq -0x18(%rbp), %rdi
callq 0x28600
movl %eax, %edx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2dcb0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2dcd0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq %rax, %rdx
callq 0x2dbd0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2db52
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xa5c0
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x28, %rdi
callq 0x26430
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rdx
addq $0x1, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0xa270
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2e22a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0xa270
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq 0x18(%rdi), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rax,%rcx,4), %rax
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
callq 0x2ba80
movq -0x38(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jne 0x2e4de
movb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x2e4de
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2e4e7
jmp 0x2e4e9
jmp 0x2e508
leaq 0x61b57(%rip), %rdi     # 0x90047
leaq 0x5fb7d(%rip), %rsi     # 0x8e074
movl $0x188, %edx            # imm = 0x188
leaq 0x61ba7(%rip), %rcx     # 0x900aa
callq 0xa330
movq -0x40(%rbp), %rcx
movq 0x18(%rcx), %rax
movq -0x10(%rbp), %rdx
movl 0x4(%rax,%rdx,4), %eax
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
cmpl $0x0, %eax
je 0x2e55e
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x50(%rbp)
addq $0x28, %rdi
callq 0x2ba80
movq -0x50(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x27e90
movslq (%rax), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x41(%rbp)
jge 0x2e565
movb $0x1, %al
movb %al, -0x41(%rbp)
jmp 0x2e565
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x2e56e
jmp 0x2e570
jmp 0x2e58f
leaq 0x61be3(%rip), %rdi     # 0x9015a
leaq 0x5faf6(%rip), %rsi     # 0x8e074
movl $0x189, %edx            # imm = 0x189
leaq 0x61b20(%rip), %rcx     # 0x900aa
callq 0xa330
movq -0x40(%rbp), %rdi
movq 0x18(%rdi), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rax,%rcx,4), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rdi), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x4(%rax,%rcx,4)
addq $0x28, %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x2baa0
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
callq 0x27ec0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 0, int>::finalize()
inline void finalize()
    {
      if(isCompressed())
      {
        StorageIndex size = internal::convert_index<StorageIndex>(m_data.size());
        Index i = m_outerSize;
        // find the last filled column
        while (i>=0 && m_outerIndex[i]==0)
          --i;
        ++i;
        while (i<=m_outerSize)
        {
          m_outerIndex[i] = size;
          ++i;
        }
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2b960
testb $0x1, %al
jne 0x2e832
jmp 0x2e8d2
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x2ba80
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x28600
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
jl 0x2e87f
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2e888
jmp 0x2e896
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2e85d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jg 0x2e8d0
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2e8a2
jmp 0x2e8d2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ec80
testb $0x1, %al
jne 0x2e927
jmp 0x2e93e
movq -0x10(%rbp), %rdi
callq 0x2eca0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x28a20
jmp 0x2e9b8
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x2e9b6
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ecb0
movq -0x10(%rbp), %rdi
callq 0x2b960
testb $0x1, %al
jne 0x2e964
jmp 0x2e9a7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x8(%rax), %rcx
shlq $0x2, %rcx
addq %rcx, %rsi
addq $0x4, %rsi
movq 0x18(%rax), %rdx
callq 0x28420
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x2ed20
jmp 0x2e9b4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2edc0
jmp 0x2e9b6
jmp 0x2e9b8
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ba80
movq -0x18(%rbp), %rdi
movq %rax, %rsi
xorps %xmm0, %xmm0
callq 0x27ee0
movq -0x10(%rbp), %rdi
callq 0x2ba80
cmpq $0x0, %rax
jle 0x2edac
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movq 0x10(%rax), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq (%rax), %rdx
callq 0x283e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rax), %rcx
shlq $0x2, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdx
callq 0x28420
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
// Function: Eigen::IterativeSolverBase<Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double, 0, int>, Eigen::LeastSquareDiagonalPreconditioner<double>>>::init()
void init()
  {
    m_isInitialized = false;
    m_analysisIsOk = false;
    m_factorizationIsOk = false;
    m_maxIterations = -1;
    m_tolerance = NumTraits<Scalar>::epsilon();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, (%rax)
movb $0x0, 0x11c(%rax)
movb $0x0, 0x11d(%rax)
movq $-0x1, 0xf8(%rax)
callq 0x351e0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x100(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35500
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x354a0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35520
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jge 0x35489
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x35540
leaq -0x40(%rbp), %rdi
callq 0x35590
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3545d
movq -0x48(%rbp), %rdi
movsd 0x58979(%rip), %xmm0    # 0x8ddb8
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rsi
callq 0x22af0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x35476
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22af0
movsd 0x58946(%rip), %xmm0    # 0x8ddb8
movsd %xmm0, (%rax)
jmp 0x35478
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x353e5
movq -0x48(%rbp), %rax
movb $0x1, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x36a90
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, 0x110(%rax)
movsd 0x100(%rax), %xmm0
movsd %xmm0, 0x108(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33580
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jge 0x36956
movq -0x98(%rbp), %rdi
callq 0x36a90
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, 0x110(%rax)
movsd 0x100(%rax), %xmm0
movsd %xmm0, 0x108(%rax)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x36af0
movq -0x98(%rbp), %rdi
callq 0x35320
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x372e0
movq -0x98(%rbp), %r9
movq -0xa8(%rbp), %rdi
movq %r9, %rcx
addq $0xe0, %rcx
movq %r9, %r8
addq $0x110, %r8             # imm = 0x110
addq $0x108, %r9             # imm = 0x108
leaq -0x90(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x36b80
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x36880
movq -0x98(%rbp), %rax
movb $0x1, (%rax)
movsd 0x108(%rax), %xmm1
movsd 0x100(%rax), %xmm0
movl $0x2, %ecx
xorl %edx, %edx
ucomisd %xmm1, %xmm0
cmovael %edx, %ecx
movl %ecx, 0x118(%rax)
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
testb $0x1, 0x10(%rcx)
movb %al, -0x21(%rbp)
je 0x3791a
movb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x3791a
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x37923
jmp 0x37925
jmp 0x37944
leaq 0x5accc(%rip), %rdi     # 0x925f8
leaq 0x5ad05(%rip), %rsi     # 0x92638
movl $0x61, %edx
leaq 0x5ad3f(%rip), %rcx     # 0x9267e
callq 0xa330
movq -0x30(%rbp), %rdi
callq 0x339a0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x339e0
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
jne 0x37972
movb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x37972
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x3797b
jmp 0x3797d
jmp 0x3799c
leaq 0x5ae07(%rip), %rdi     # 0x9278b
leaq 0x5acad(%rip), %rsi     # 0x92638
movl $0x63, %edx
leaq 0x5ace7(%rip), %rcx     # 0x9267e
callq 0xa330
movq -0x20(%rbp), %rdi
callq 0x33a40
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq -0x10(%rbp), %rdi
callq 0x3bfe0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x39de0
movq -0x8(%rbp), %rdi
callq 0x39e10
movq %rax, -0x68(%rbp)
jmp 0x39d17
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33580
movq %rax, -0x70(%rbp)
jmp 0x39d3e
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
cmpq %rcx, %rax
jge 0x39db6
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x39da3
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x60(%rbp), %r8
movq -0x58(%rbp), %r9
leaq -0x38(%rbp), %rdi
callq 0x39e30
jmp 0x39d7c
jmp 0x39d7e
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x39d53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x39f20
jmp 0x39dc8
jmp 0x39da5
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x39d27
leaq -0x38(%rbp), %rdi
callq 0x39f20
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xa950
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x3a040
leaq -0x60(%rbp), %rdi
callq 0x36150
testb $0x1, %al
jne 0x39e7b
jmp 0x39ed4
leaq -0x60(%rbp), %rdi
callq 0x36320
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x36170
movq -0x70(%rbp), %rdi
movslq %eax, %rsi
movq -0x30(%rbp), %rdx
callq 0x3a080
movsd -0x68(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x36190
jmp 0x39e6c
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x39490
movsd -0x80(%rbp), %xmm0
movsd -0x78(%rbp), %xmm2
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
addq $0x80, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x7e717(%rip), %rdi     # 0xbef98
leaq 0x53680(%rip), %rsi     # 0x93f08
callq 0xa4a0
movq %rax, %rdi
movq 0x7e691(%rip), %rsi     # 0xbef28
callq 0xa500
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xa200
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x40960
jmp 0x408bc
leaq -0x38(%rbp), %rdi
callq 0xaaa8
movq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xa200
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x411c0
jmp 0x408ee
leaq -0x68(%rbp), %rdi
callq 0xaaa8
movq 0x7e69a(%rip), %rdi     # 0xbef98
movq 0x7e623(%rip), %rsi     # 0xbef28
callq 0xa500
movq -0x78(%rbp), %rdi
callq 0x416a0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xaaa8
jmp 0x40948
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xaaa8
movq -0x40(%rbp), %rdi
callq 0xa950
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
callq 0x20110
movq -0x20(%rbp), %rax
movsd %xmm0, -0x10(%rbp)
movq (%rax), %rdi
callq 0x20180
movq -0x20(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
testb $0x1, 0x28(%rax)
je 0x417b2
movq 0x7d8b1(%rip), %rdi     # 0xbef98
leaq 0x528bc(%rip), %rsi     # 0x93faa
callq 0xa4a0
movq %rax, %rdi
movq 0x7d82b(%rip), %rsi     # 0xbef28
callq 0xa500
movq 0x7d88f(%rip), %rdi     # 0xbef98
leaq 0x528ba(%rip), %rsi     # 0x93fca
callq 0xa4a0
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0xa9f0
movq %rax, %rdi
movq 0x7d7fc(%rip), %rsi     # 0xbef28
callq 0xa500
movq 0x7d860(%rip), %rdi     # 0xbef98
leaq 0x528a8(%rip), %rsi     # 0x93fe7
callq 0xa4a0
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0xa9f0
movq %rax, %rdi
movq 0x7d7cd(%rip), %rsi     # 0xbef28
callq 0xa500
movq 0x7d831(%rip), %rdi     # 0xbef98
leaq 0x5289a(%rip), %rsi     # 0x94008
callq 0xa4a0
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movaps 0x4c619(%rip), %xmm1    # 0x8dda0
pand %xmm1, %xmm0
callq 0xa9f0
movq %rax, %rdi
movq 0x7d78e(%rip), %rsi     # 0xbef28
callq 0xa500
movq 0x7d7f2(%rip), %rdi     # 0xbef98
movq 0x7d77b(%rip), %rsi     # 0xbef28
callq 0xa500
jmp 0x417b4
movsd -0x10(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
movaps 0x4c5db(%rip), %xmm0    # 0x8dda0
pand %xmm0, %xmm1
divsd -0x10(%rbp), %xmm1
movsd 0x5272a(%rip), %xmm0    # 0x93f00
ucomisd %xmm1, %xmm0
ja 0x41879
movq 0x7d7f9(%rip), %rdi     # 0xbefe0
leaq 0x52828(%rip), %rsi     # 0x94016
callq 0xa4a0
movq %rax, %rdi
leaq 0x52731(%rip), %rsi     # 0x93f2e
callq 0xa4a0
movq %rax, %rdi
leaq 0x4c6f7(%rip), %rsi     # 0x8df03
callq 0xa4a0
movq %rax, %rdi
movl $0x5e, %esi
callq 0xa920
movq %rax, %rdi
leaq 0x4bc13(%rip), %rsi     # 0x8d43b
callq 0xa4a0
movq %rax, %rdi
leaq 0x5283c(%rip), %rsi     # 0x94073
callq 0xa4a0
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0xa9f0
movq %rax, %rdi
leaq 0x5282e(%rip), %rsi     # 0x94081
callq 0xa4a0
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0xa9f0
movq %rax, %rdi
movq 0x7d6b9(%rip), %rsi     # 0xbef28
callq 0xa500
callq 0xa170
jmp 0x4187b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: icemiliang[P]vot/src/vot/ot.cc
// Function: vot::OT::setup(int, int, double, double, bool, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void OT::setup(const int pMaxIterD, const int pMaxIterH, const double pThres, 
                   const double pLearnRate, const bool pFlagVerbose, const double pPlotScale,
                   const std::string pFilePrefix, const bool pFlagDebug) {
        mFlagVerbose = pFlagVerbose;
        mOutFilePrefix = pFilePrefix;
        mMaxIterD = pMaxIterD;
        mMaxIterH = pMaxIterH;
        mThres = pThres;
        mLearnRate = pLearnRate;
        mMethod = pLearnRate > 0.0 ? METHOD_GD : METHOD_NEWTON;

        mDiagram->setup(pFlagVerbose, pFlagDebug);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %r8, -0x58(%rbp)
movl %esi, %eax
movq -0x58(%rbp), %rsi
movl %eax, -0x4c(%rbp)
movq %rdi, %r8
movl -0x4c(%rbp), %edi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
movsd %xmm2, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, 0x28(%rdi)
addq $0x8, %rdi
callq 0xa060
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x30(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x38(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x40(%rax)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
movl $0x2, %ecx
movl $0x1, %edx
ucomisd %xmm1, %xmm0
cmoval %edx, %ecx
movl %ecx, 0x48(%rax)
movq (%rax), %rdi
movb -0x21(%rbp), %cl
movb -0x39(%rbp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0x1ef90
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x78(%rbp)
movl $0x0, -0xc(%rbp)
movq (%rsi), %rax
movq %rax, -0x70(%rbp)
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa200
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rcx
xorl %edx, %edx
movl %edx, %esi
callq 0x1f8e0
jmp 0x41999
leaq -0x30(%rbp), %rdi
callq 0xaaa8
movq -0x78(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x41a94
movl $0x0, -0x40(%rbp)
movq -0x78(%rbp), %rcx
movl -0x40(%rbp), %eax
cmpl 0x30(%rcx), %eax
jge 0x41a11
movq -0x78(%rbp), %rax
movq (%rax), %rdi
movl 0x48(%rax), %esi
movsd 0x38(%rax), %xmm0
movsd 0x40(%rax), %xmm1
movl -0xc(%rbp), %edx
movl -0x40(%rbp), %ecx
callq 0x201f0
testb $0x1, %al
jne 0x419ea
jmp 0x41a06
jmp 0x41a11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xaaa8
jmp 0x41a9d
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x419b9
movq -0x78(%rbp), %rax
movq (%rax), %rdi
callq 0x20bc0
testb $0x1, %al
jne 0x41a23
jmp 0x41a25
jmp 0x41a94
movq -0x78(%rbp), %rsi
movl -0xc(%rbp), %eax
incl %eax
movl %eax, -0xc(%rbp)
movq (%rsi), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x84(%rbp)
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa200
movq -0x90(%rbp), %rdi
movl -0x84(%rbp), %esi
movq -0x80(%rbp), %rcx
xorl %edx, %edx
callq 0x1f8e0
jmp 0x41a6f
leaq -0x60(%rbp), %rdi
callq 0xaaa8
jmp 0x419a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xaaa8
jmp 0x41a9d
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xa950
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x14(%rax), %ecx
shll %ecx
movl %ecx, 0x14(%rax)
cmpl $0x1000000, 0x14(%rax)  # imm = 0x1000000
jle 0x41eba
leaq 0x524ae(%rip), %rdi     # 0x9435e
movl $0x2, %esi
callq 0x4c000
movq -0x30(%rbp), %rax
movslq 0x14(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xa030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x41f2f
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x28(%rbp)
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x20(%rbp)
movl %ecx, (%rax)
jmp 0x41efe
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x41f4a
movq -0x38(%rbp), %rdi
callq 0xa660
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x60(%rax), %rcx
movslq 0x14(%rax), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x68(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x10(%rax), %ecx
shll %ecx
movl %ecx, 0x10(%rax)
cmpl $0x1000000, 0x10(%rax)  # imm = 0x1000000
jle 0x41fba
leaq 0x52373(%rip), %rdi     # 0x94323
movl $0x2, %esi
callq 0x4c000
movq -0x30(%rbp), %rax
movslq 0x10(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xa030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x4202f
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x28(%rbp)
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x20(%rbp)
movl %ecx, (%rax)
jmp 0x41ffe
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4204a
movq -0x38(%rbp), %rdi
callq 0xa660
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x50(%rax), %rcx
movslq 0x10(%rax), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x58(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x7c86d(%rip), %rcx     # 0xbec68
addq $0x10, %rcx
movq %rcx, (%rax)
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x42455
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x42448
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x42446
movq -0x20(%rbp), %rdi
callq 0xa660
jmp 0x42448
jmp 0x4244a
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4240b
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x42470
movq -0x28(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4248b
movq -0x30(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x424a6
movq -0x38(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x424c1
movq -0x40(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x424dc
movq -0x48(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x424f7
movq -0x50(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x42512
movq -0x58(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x4252d
movq -0x60(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x42548
movq -0x68(%rbp), %rdi
callq 0xa660
addq $0x70, %rsp
popq %rbp
retq
nop
// File: icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::translate(double, double, double)
void voronoicell_base::translate(double x,double y,double z) {
    x*=2;y*=2;z*=2;
    double *ptsp=pts;
    while(ptsp<pts+3*p) {
        *(ptsp++)=x;*(ptsp++)=y;*(ptsp++)=z;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd 0x516f9(%rip), %xmm0    # 0x940c0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x516e7(%rip), %xmm0    # 0x940c0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x516d5(%rip), %xmm0    # 0x940c0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x30(%rdx), %rcx
imull $0x3, 0x18(%rdx), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x42a66
movsd -0x10(%rbp), %xmm0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
movsd %xmm0, (%rax)
jmp 0x429fd
popq %rbp
retq
nopl (%rax,%rax)
// File: icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::max_radius_squared()
double voronoicell_base::max_radius_squared() {
    double r,s,*ptsp=pts+3,*ptse=pts+3*p;
    r=*pts*(*pts)+pts[1]*pts[1]+pts[2]*pts[2];
    while(ptsp<ptse) {
        s=*ptsp*(*ptsp);ptsp++;
        s+=*ptsp*(*ptsp);ptsp++;
        s+=*ptsp*(*ptsp);ptsp++;
        if(s>r) r=s;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x30(%rax), %rcx
addq $0x18, %rcx
movq %rcx, -0x20(%rbp)
movq 0x30(%rax), %rcx
imull $0x3, 0x18(%rax), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm1
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm2
movq 0x30(%rax), %rcx
movsd 0x8(%rcx), %xmm0
movq 0x30(%rax), %rcx
mulsd 0x8(%rcx), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq 0x30(%rax), %rcx
movsd 0x10(%rcx), %xmm0
movq 0x30(%rax), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x44d81
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x44d7c
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x44cdb
movsd -0x10(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)