LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Luthaf[P]zeopp/OMS.cc
// Function: Sort(double**, int, int)
void Sort(	double **MoleculeCoordinates, 
		int Criterion,
		int Size)
{

	int i,j;
	double *Swap;

	for (i = 0 ; i < Size-1; i++)
		for (j = 0 ; j < Size - i - 1; j++)
			if (MoleculeCoordinates[j][Criterion] > MoleculeCoordinates[j+1][Criterion]) 
			{
				Swap = MoleculeCoordinates[j];
				MoleculeCoordinates[j] = MoleculeCoordinates[j+1];
				MoleculeCoordinates[j+1] = Swap;
			}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x173dd4
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
subl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x173dc4
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x173db4
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x173db6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x173d2d
jmp 0x173dc6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x173d15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/OMS.cc
// Function: LinearlyDependent(double*, double*)
bool LinearlyDependent (double *Vector1, double *Vector2)
{

	Vector3d v1(Vector1[X_COORD], Vector1[Y_COORD], Vector1[Z_COORD]);
	Vector3d v2(Vector2[X_COORD], Vector2[Y_COORD], Vector2[Z_COORD]);

	v1 = v1.cross(v2);

	//cout << "Checking LD: \n" << Vector1[0] << Vector1[1] << Vector1[2] << "\n" << Vector2[0] << Vector2[1] << Vector2[2] << "\n" << v1 << "\n";	

	//if (v1(0) == 0 && v1(1) == 0 && v2(0) == 0)
	if ( v1(0)*v1(0)+v1(1)*v1(1)+v1(2)*v1(2) == 0)
	{
		//cout << "Vectors are lin dep " << v1(0)*v1(0)+v1(1)*v1(1)+v1(2)*v1(2) << "\n";
		return true;
	}

	
	return false;



}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
leaq -0x30(%rbp), %rdi
callq 0x174e70
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
leaq -0x48(%rbp), %rdi
callq 0x174e70
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x174f00
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x175150
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x175180
movsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x175180
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x175180
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x175180
movsd -0x88(%rbp), %xmm1
movsd -0x80(%rbp), %xmm0
movsd -0x78(%rbp), %xmm2
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x175180
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x175180
movsd -0x70(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x173f0e
jp 0x173f0e
movb $0x1, -0x1(%rbp)
jmp 0x173f12
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/OMS.cc
// Function: Sign(double)
int Sign(double Lambda)
{
	if (Lambda > 0)
		return 1;

	if (Lambda == 0)
		return 0;

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1741b0
movl $0x1, -0x4(%rbp)
jmp 0x1741d0
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1741c9
jp 0x1741c9
movl $0x0, -0x4(%rbp)
jmp 0x1741d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/util/Memory.h
// Function: long Eigen::internal::first_aligned<double, long>(double const*, long)
static inline Index first_aligned(const Scalar* array, Index size)
{
  static const Index PacketSize = packet_traits<Scalar>::size;
  static const Index PacketAlignedMask = PacketSize-1;

  if(PacketSize==1)
  {
    // Either there is no vectorization, or a packet consists of exactly 1 scalar so that all elements
    // of the array have the same alignment.
    return 0;
  }
  else if(size_t(array) & (sizeof(Scalar)-1))
  {
    // There is vectorization for this scalar type, but the array is not aligned to the size of a single scalar.
    // Consequently, no element of the array is well aligned.
    return size;
  }
  else
  {
    return std::min<Index>( (PacketSize - (Index((size_t(array)/sizeof(Scalar))) & PacketAlignedMask))
                           & PacketAlignedMask, size);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x174e28
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x174e58
movq -0x10(%rbp), %rcx
shrq $0x3, %rcx
andq $0x1, %rcx
movl $0x2, %eax
subq %rcx, %rax
andq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x175fd0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/Matrix.h
// Function: Eigen::Matrix<double, 3, 1, 0, 3, 1>::Matrix(double const&, double const&, double const&)
EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z)
    {
      Base::_check_template_params();
      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 3)
      m_storage.data()[0] = x;
      m_storage.data()[1] = y;
      m_storage.data()[2] = z;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x175490
callq 0x1754c0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x1754d0
movsd -0x40(%rbp), %xmm0
movq -0x30(%rbp), %rdi
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x1754d0
movsd -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rdi
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x1754d0
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/./Eigen/src/Core/Swap.h
// Function: void Eigen::SwapWrapper<Eigen::Matrix<double, 3, 1, 0, 3, 1>>::copyCoeff<Eigen::Matrix<double, 3, 1, 0, 3, 1>>(long, Eigen::DenseBase<Eigen::Matrix<double, 3, 1, 0, 3, 1>> const&)
void copyCoeff(Index index, const DenseBase<OtherDerived>& other)
    {
      OtherDerived& _other = other.const_cast_derived();
      eigen_internal_assert(index >= 0 && index < m_expression.size());
      Scalar tmp = m_expression.coeff(index);
      m_expression.coeffRef(index) = _other.coeff(index);
      _other.coeffRef(index) = tmp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1756b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x175590
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x175590
movq %rax, %rcx
movq -0x40(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x38(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x175b50
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x175b50
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/Matrix.h
// Function: Eigen::Matrix<double, 3, 1, 0, 3, 1>::Matrix(long)
Matrix(Index dim)
      : Base(dim, RowsAtCompileTime == 1 ? 1 : dim, ColsAtCompileTime == 1 ? 1 : dim)
    {
      Base::_check_template_params();
      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Matrix)
      eigen_assert(dim >= 0);
      eigen_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == dim);
      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x1769a0
callq 0x1754c0
cmpq $0x0, -0x10(%rbp)
jl 0x176044
jmp 0x176063
leaq 0x89bea(%rip), %rdi     # 0x1ffc35
leaq 0x89bec(%rip), %rsi     # 0x1ffc3e
movl $0xf0, %edx
leaq 0x89bfa(%rip), %rcx     # 0x1ffc58
callq 0x5320
movl $0x3, %eax
cmpq -0x10(%rbp), %rax
jne 0x176070
jmp 0x17608f
leaq 0x89c5f(%rip), %rdi     # 0x1ffcd6
leaq 0x89bc0(%rip), %rsi     # 0x1ffc3e
movl $0xf1, %edx
leaq 0x89bce(%rip), %rcx     # 0x1ffc58
callq 0x5320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Luthaf[P]zeopp/./Eigen/src/Core/PlainObjectBase.h
// Function: Eigen::PlainObjectBase<Eigen::Matrix<double, 3, 3, 0, 3, 3>>::resize(long, long)
EIGEN_STRONG_INLINE void resize(Index nbRows, Index nbCols)
    {
      eigen_assert(   EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,nbRows==RowsAtCompileTime)
                   && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,nbCols==ColsAtCompileTime)
                   && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,nbRows<=MaxRowsAtCompileTime)
                   && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,nbCols<=MaxColsAtCompileTime)
                   && nbRows>=0 && nbCols>=0 && "Invalid sizes when resizing a matrix or array.");
      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(nbRows, nbCols);
      #ifdef EIGEN_INITIALIZE_COEFFS
        Index size = nbRows*nbCols;
        bool size_changed = size != this->size();
        m_storage.resize(size, nbRows, nbCols);
        if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
      #else
        internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(nbRows, nbCols);
        m_storage.resize(nbRows*nbCols, nbRows, nbCols);
      #endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
cmpq $0x3, -0x30(%rbp)
movb %al, -0x39(%rbp)
jne 0x176913
xorl %eax, %eax
cmpq $0x3, -0x38(%rbp)
movb %al, -0x39(%rbp)
jne 0x176913
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x39(%rbp)
jl 0x176913
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x39(%rbp)
jl 0x176913
movb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x176913
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x17691c
jmp 0x17691e
jmp 0x17693d
leaq 0x890db(%rip), %rdi     # 0x1ffa00
leaq 0x8926f(%rip), %rsi     # 0x1ffb9b
movl $0xf1, %edx
leaq 0x89286(%rip), %rcx     # 0x1ffbbe
callq 0x5320
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rsi
imulq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x176980
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Householder/Householder.h
// Function: void Eigen::MatrixBase<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>>::applyHouseholderOnTheLeft<Eigen::VectorBlock<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1>>(Eigen::VectorBlock<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1> const&, double const&, double*)
void MatrixBase<Derived>::applyHouseholderOnTheLeft(
  const EssentialPart& essential,
  const Scalar& tau,
  Scalar* workspace)
{
  if(rows() == 1)
  {
    *this *= Scalar(1)-tau;
  }
  else
  {
    Map<typename internal::plain_row_type<PlainObject>::type> tmp(workspace,cols());
    Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows()-1, cols());
    tmp.noalias() = essential.adjoint() * bottom;
    tmp += this->row(0);
    this->row(0) -= tau * tmp;
    bottom.noalias() -= tau * essential * tmp;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp            # imm = 0x350
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x330(%rbp)
callq 0x17cdd0
cmpq $0x1, %rax
jne 0x17736b
movq -0x330(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x7acfc(%rip), %xmm0    # 0x1f2050
subsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x17ce00
jmp 0x17750c
movq -0x330(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x350(%rbp)
callq 0x17ce90
movq %rax, -0x348(%rbp)
leaq -0x4a(%rbp), %rdi
callq 0x17cec0
movq -0x350(%rbp), %rsi
movq -0x348(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x4a(%rbp), %rcx
callq 0x17cf00
movq -0x330(%rbp), %rdi
callq 0x17cf60
movq -0x330(%rbp), %rdi
movq %rax, -0x340(%rbp)
callq 0x17cdd0
movq -0x330(%rbp), %rdi
subq $0x1, %rax
movq %rax, -0x338(%rbp)
callq 0x17ce90
movq -0x340(%rbp), %rsi
movq -0x338(%rbp), %r8
movq %rax, %r9
leaq -0x98(%rbp), %rdi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x17cf70
movq -0x10(%rbp), %rsi
leaq -0x180(%rbp), %rdi
callq 0x17d060
leaq -0x140(%rbp), %rdi
leaq -0x180(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x17d090
leaq -0x48(%rbp), %rdi
callq 0x17d0e0
movq %rax, -0x188(%rbp)
leaq -0x188(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x17d110
movq -0x330(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x17d150
leaq -0x48(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x17d1a0
movq -0x18(%rbp), %rsi
leaq -0x1f8(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x17d200
movq -0x330(%rbp), %rsi
leaq -0x240(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x17d150
leaq -0x240(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x17d240
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x320(%rbp), %rdi
callq 0x17d2a0
leaq -0x2d8(%rbp), %rdi
leaq -0x320(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x17d2e0
leaq -0x98(%rbp), %rdi
callq 0x17d330
movq %rax, -0x328(%rbp)
leaq -0x328(%rbp), %rdi
leaq -0x2d8(%rbp), %rsi
callq 0x17d360
addq $0x350, %rsp            # imm = 0x350
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Luthaf[P]zeopp/./Eigen/src/Core/MapBase.h
// Function: Eigen::MapBase<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, 0>::MapBase(double*, long, long)
inline MapBase(PointerType dataPtr, Index nbRows, Index nbCols)
            : m_data(dataPtr), m_rows(nbRows), m_cols(nbCols)
    {
      eigen_assert( (dataPtr == 0)
              || (   nbRows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == nbRows)
                  && nbCols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == nbCols)));
      checkSanity();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x178120
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x178140
movq -0x30(%rbp), %rdi
addq $0x9, %rdi
movq -0x20(%rbp), %rsi
callq 0x178180
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x1780e7
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x31(%rbp)
jl 0x1780e1
xorl %eax, %eax
movl $0x3, %ecx
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
jne 0x1780e1
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x31(%rbp)
jl 0x1780e1
movl $0x1, %eax
cmpq -0x20(%rbp), %rax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1780f0
jmp 0x1780f2
jmp 0x178111
leaq 0x8827d(%rip), %rdi     # 0x200376
leaq 0x88328(%rip), %rsi     # 0x200428
movl $0x94, %edx
leaq 0x88337(%rip), %rcx     # 0x200443
callq 0x5320
movq -0x30(%rbp), %rdi
callq 0x1781c0
addq $0x40, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/./Eigen/src/Core/Block.h
// Function: Eigen::Block<Eigen::Matrix<double, 1, 3, 1, 1, 3>, 1, -1, false>::Block(Eigen::Matrix<double, 1, 3, 1, 1, 3>&, long, long, long, long)
inline Block(XprType& xpr,
          Index a_startRow, Index a_startCol,
          Index blockRows, Index blockCols)
      : Impl(xpr, a_startRow, a_startCol, blockRows, blockCols)
    {
      eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
          && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
      eigen_assert(a_startRow >= 0 && blockRows >= 0 && a_startRow  <= xpr.rows() - blockRows
          && a_startCol >= 0 && blockCols >= 0 && a_startCol <= xpr.cols() - blockCols);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x178fa0
xorl %eax, %eax
movl $0x1, %ecx
cmpq -0x28(%rbp), %rcx
movb %al, -0x31(%rbp)
jne 0x178ec4
movb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x178ec4
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x178ecd
jmp 0x178ecf
jmp 0x178eee
leaq 0x8770f(%rip), %rdi     # 0x2005e5
leaq 0x873d8(%rip), %rsi     # 0x2002b5
movl $0x8c, %edx
leaq 0x87779(%rip), %rcx     # 0x200662
callq 0x5320
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x32(%rbp)
jl 0x178f69
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x32(%rbp)
jl 0x178f69
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x178e20
movq -0x40(%rbp), %rcx
movq %rax, %rdx
subq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x32(%rbp)
jg 0x178f69
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x32(%rbp)
jl 0x178f69
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x32(%rbp)
jl 0x178f69
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x178e50
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq -0x30(%rbp), %rcx
cmpq %rcx, %rax
setle %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x178f72
jmp 0x178f74
jmp 0x178f93
leaq 0x8779d(%rip), %rdi     # 0x200718
leaq 0x87333(%rip), %rsi     # 0x2002b5
movl $0x8e, %edx
leaq 0x876d4(%rip), %rcx     # 0x200662
callq 0x5320
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/Visitor.h
// Function: Eigen::internal::visitor_impl<Eigen::internal::max_coeff_visitor<Eigen::Block<Eigen::Matrix<double, 1, 3, 1, 1, 3>, 1, -1, false>>, Eigen::Block<Eigen::Matrix<double, 1, 3, 1, 1, 3>, 1, -1, false>, -1>::run(Eigen::Block<Eigen::Matrix<double, 1, 3, 1, 1, 3>, 1, -1, false> const&, Eigen::internal::max_coeff_visitor<Eigen::Block<Eigen::Matrix<double, 1, 3, 1, 1, 3>, 1, -1, false>>&)
static inline void run(const Derived& mat, Visitor& visitor)
  {
    visitor.init(mat.coeff(0,0), 0, 0);
    for(Index i = 1; i < mat.rows(); ++i)
      visitor(mat.coeff(i, 0), i, 0);
    for(Index j = 1; j < mat.cols(); ++j)
      for(Index i = 0; i < mat.rows(); ++i)
        visitor(mat.coeff(i, j), i, j);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x179460
movq -0x30(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x179420
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1794e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jge 0x17936b
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x179460
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x179500
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x179313
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x179550
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jge 0x179403
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1794e0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jge 0x1793f0
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x179460
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x179500
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x179398
jmp 0x1793f2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x179373
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/Visitor.h
// Function: Eigen::internal::max_coeff_visitor<Eigen::Block<Eigen::Matrix<double, 1, 3, 1, 1, 3>, 1, -1, false>>::operator()(double const&, long, long)
void operator() (const Scalar& value, Index i, Index j)
  {
    if(value > this->res)
    {
      this->res = value;
      this->row = i;
      this->col = j;
    }
  }

// 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, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
ucomisd 0x10(%rax), %xmm0
jbe 0x17954b
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/Redux.h
// Function: Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double>, Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const>, 0, 0>::run(Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const> const&, Eigen::internal::scalar_sum_op<double> const&)
static EIGEN_STRONG_INLINE Scalar run(const Derived& mat, const Func& func)
  {
    eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
    Scalar res;
    res = mat.coeffByOuterInner(0, 0);
    for(Index i = 1; i < mat.innerSize(); ++i)
      res = func(res, mat.coeffByOuterInner(0, i));
    for(Index i = 1; i < mat.outerSize(); ++i)
      for(Index j = 0; j < mat.innerSize(); ++j)
        res = func(res, mat.coeffByOuterInner(i, j));
    return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x179f00
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x41(%rbp)
jle 0x179fc5
movq -0x8(%rbp), %rdi
callq 0x179f40
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x41(%rbp)
jle 0x179fc5
movb $0x1, %al
movb %al, -0x41(%rbp)
jmp 0x179fc5
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x179fce
jmp 0x179fd0
jmp 0x179fef
leaq 0x86a70(%rip), %rdi     # 0x200a47
leaq 0x86aa9(%rip), %rsi     # 0x200a87
movl $0xaf, %edx
leaq 0x86ab6(%rip), %rcx     # 0x200aa0
callq 0x5320
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x17a120
movsd %xmm0, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17a180
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jge 0x17a06b
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x17a120
movq -0x58(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
leaq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x1785a0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x17a00c
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17a1a0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jge 0x17a10a
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17a180
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jge 0x17a0f7
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x17a120
movq -0x70(%rbp), %rdi
movsd %xmm0, -0x40(%rbp)
leaq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x1785a0
movsd %xmm0, -0x18(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x17a098
jmp 0x17a0f9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x17a073
movsd -0x18(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Luthaf[P]zeopp/./Eigen/src/Core/CwiseNullaryOp.h
// Function: Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Block<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false>, -1, 1, false>>::CwiseNullaryOp(long, long, Eigen::internal::scalar_constant_op<double> const&)
CwiseNullaryOp(Index nbRows, Index nbCols, const NullaryOp& func = NullaryOp())
      : m_rows(nbRows), m_cols(nbCols), m_functor(func)
    {
      eigen_assert(nbRows >= 0
            && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == nbRows)
            &&  nbCols >= 0
            && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == nbCols));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x17bfe0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x179220
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x178180
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0x17c000
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
jl 0x17bfab
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
jl 0x17bfab
movl $0x1, %eax
cmpq -0x18(%rbp), %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x17bfb4
jmp 0x17bfb6
jmp 0x17bfd5
leaq 0x85484(%rip), %rdi     # 0x201441
leaq 0x8551a(%rip), %rsi     # 0x2014de
movl $0x3f, %edx
leaq 0x85530(%rip), %rcx     # 0x201500
callq 0x5320
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/SelfCwiseBinaryOp.h
// Function: Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, 3, 3>>>& Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, 3, 3>>>::lazyAssign<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, 3, 3>>>(Eigen::DenseBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, 3, 3>>> const&)
EIGEN_STRONG_INLINE SelfCwiseBinaryOp& lazyAssign(const DenseBase<RhsDerived>& rhs)
    {
      EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs,RhsDerived)
      EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename RhsDerived::Scalar);
      
    #ifdef EIGEN_DEBUG_ASSIGN
      internal::assign_traits<SelfCwiseBinaryOp, RhsDerived>::debug();
    #endif
      eigen_assert(rows() == rhs.rows() && cols() == rhs.cols());
      internal::assign_impl<SelfCwiseBinaryOp, RhsDerived>::run(*this,rhs.derived());
    #ifndef EIGEN_NO_DEBUG
      this->checkTransposeAliasing(rhs.derived());
    #endif
      return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x17d7f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17d810
movq -0x20(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
jne 0x17d791
movq -0x28(%rbp), %rdi
callq 0x17d840
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17d860
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x17d79a
jmp 0x17d79c
jmp 0x17d7bb
leaq 0x844d6(%rip), %rdi     # 0x201c79
leaq 0x844fc(%rip), %rsi     # 0x201ca6
movl $0x88, %edx
leaq 0x84515(%rip), %rcx     # 0x201ccb
callq 0x5320
movq -0x10(%rbp), %rdi
callq 0x17d720
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x17d890
movq -0x10(%rbp), %rdi
callq 0x17d720
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x17d920
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/./Eigen/src/Core/Assign.h
// Function: Eigen::internal::assign_impl<Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, 3, 3>>>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, 3, 3>>, 0, 0, 0>::run(Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, 3, 3>>>&, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, 3, 3>> const&)
static inline void run(Derived1 &dst, const Derived2 &src)
  {
    const Index innerSize = dst.innerSize();
    const Index outerSize = dst.outerSize();
    for(Index outer = 0; outer < outerSize; ++outer)
      for(Index inner = 0; inner < innerSize; ++inner)
        dst.copyCoeffByOuterInner(outer, inner, src);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17d9b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17d9d0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x17d911
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x17d901
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x17d9f0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x17d8d4
jmp 0x17d903
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x17d8c2
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/MapBase.h
// Function: Eigen::MapBase<Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>>, 0>::MapBase(double*, long)
inline MapBase(PointerType dataPtr, Index vecSize)
            : m_data(dataPtr),
              m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
              m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime))
    {
      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
      eigen_assert(vecSize >= 0);
      eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize);
      checkSanity();
    }

// 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, -0x20(%rbp)
callq 0x17df70
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movl $0x1, %esi
callq 0x178180
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x179220
cmpq $0x0, -0x18(%rbp)
jl 0x17dee4
jmp 0x17df03
leaq 0x840bb(%rip), %rdi     # 0x201fa6
leaq 0x82536(%rip), %rsi     # 0x200428
movl $0x8a, %edx
leaq 0x840b5(%rip), %rcx     # 0x201fb3
callq 0x5320
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x17df2b
movb $0x1, %al
testb $0x1, %al
movb %al, -0x21(%rbp)
jne 0x17df2b
jmp 0x17df1a
movq $-0x1, %rax
cmpq -0x18(%rbp), %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x17df34
jmp 0x17df36
jmp 0x17df55
leaq 0x84121(%rip), %rdi     # 0x20205e
leaq 0x824e4(%rip), %rsi     # 0x200428
movl $0x8b, %edx
leaq 0x84063(%rip), %rcx     # 0x201fb3
callq 0x5320
movq -0x20(%rbp), %rdi
callq 0x17df90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Luthaf[P]zeopp/./Eigen/src/Core/products/CoeffBasedProduct.h
// Function: Eigen::CoeffBasedProduct<Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const> const, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false> const, 6>::CoeffBasedProduct<Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false>>(Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const> const&, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false> const&)
inline CoeffBasedProduct(const Lhs& lhs, const Rhs& rhs)
      : m_lhs(lhs), m_rhs(rhs)
    {
      // we don't allow taking products of matrices of different real types, as that wouldn't be vectorizable.
      // We still allow to mix T and complex<T>.
      EIGEN_STATIC_ASSERT((internal::scalar_product_traits<typename Lhs::RealScalar, typename Rhs::RealScalar>::Defined),
        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
      eigen_assert(lhs.cols() == rhs.rows()
        && "invalid matrix product"
        && "if you wanted a coeff-wise or a dot product use the respective explicit functions");
    }

// 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, -0x30(%rbp)
callq 0x17e3e0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17e400
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
movl $0x48, %edx
callq 0x5430
movq -0x30(%rbp), %rdi
addq $0x88, %rdi
callq 0x17e430
movq -0x10(%rbp), %rdi
callq 0x17e450
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17e470
movq -0x28(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jne 0x17e3a2
movb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x17e3a2
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x17e3ab
jmp 0x17e3ad
jmp 0x17e3cc
leaq 0x83ed7(%rip), %rdi     # 0x20228b
leaq 0x83f5c(%rip), %rsi     # 0x202317
movl $0x9e, %edx
leaq 0x83f7e(%rip), %rcx     # 0x202345
callq 0x5320
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Householder/HouseholderSequence.h
// Function: void Eigen::HouseholderSequence<Eigen::Matrix<double, 3, 3, 0, 3, 3>, Eigen::Matrix<double, 3, 1, 0, 3, 1>, 1>::applyThisOnTheLeft<Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 1, 1, 1, 1, 1>>(Eigen::Matrix<double, 3, 1, 0, 3, 1>&, Eigen::Matrix<double, 1, 1, 1, 1, 1>&) const
inline void applyThisOnTheLeft(Dest& dst, Workspace& workspace) const
    {
      workspace.resize(dst.cols());
      for(Index k = 0; k < m_length; ++k)
      {
        Index actual_k = m_trans ? k : m_length-k-1;
        dst.bottomRows(rows()-m_shift-actual_k)
           .applyHouseholderOnTheLeft(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x175a00
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x185ef0
movq $0x0, -0x20(%rbp)
movq -0x88(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x18(%rcx), %rax
jge 0x185e04
movq -0x88(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x185d46
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x185d60
movq -0x88(%rbp), %rax
movq 0x18(%rax), %rax
subq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x90(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x185ff0
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
movq -0x88(%rbp), %rax
subq 0x20(%rax), %rdx
subq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x185f70
movq -0x88(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x186220
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x175590
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1862b0
movq -0x98(%rbp), %rdx
movq %rax, %rcx
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x186010
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x185d17
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/GeneralProduct.h
// Function: void Eigen::internal::outer_product_selector_run<Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3> const, -1, 1, false> const>, Eigen::Map<Eigen::Matrix<double, 1, 1, 1, 1, 1>, 0, Eigen::Stride<0, 0>>, 2>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 1, 0, 3, 1>, -1, 1, false>, -1, 1, false>, Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3> const, -1, 1, false> const>, Eigen::Map<Eigen::Matrix<double, 1, 1, 1, 1, 1>, 0, Eigen::Stride<0, 0>>, 2>::sub>(Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3> const, -1, 1, false> const>, Eigen::Map<Eigen::Matrix<double, 1, 1, 1, 1, 1>, 0, Eigen::Stride<0, 0>>, 2> const&, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 1, 0, 3, 1>, -1, 1, false>, -1, 1, false>&, Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3> const, -1, 1, false> const>, Eigen::Map<Eigen::Matrix<double, 1, 1, 1, 1, 1>, 0, Eigen::Stride<0, 0>>, 2>::sub const&, Eigen::internal::false_type const&)
EIGEN_DONT_INLINE void outer_product_selector_run(const ProductType& prod, Dest& dest, const Func& func, const false_type&)
{
  typedef typename Dest::Index Index;
  // FIXME make sure lhs is sequentially stored
  // FIXME not very good if rhs is real and lhs complex while alpha is real too
  const Index cols = dest.cols();
  for (Index j=0; j<cols; ++j)
    func(dest.col(j), prod.rhs().coeff(0,j) * prod.lhs());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x188150
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x18a927
movq -0x18(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x18a970
movq -0x8(%rbp), %rdi
callq 0x18aa00
movq %rax, %rdi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x18a450
movq %rax, -0xe8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18aa20
movq -0xe8(%rbp), %rsi
movq %rax, %rdx
leaq -0xd8(%rbp), %rdi
callq 0x18a9c0
movq -0xe0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x18a930
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x18a890
addq $0xf0, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/./Eigen/src/Core/SolveTriangular.h
// Function: void Eigen::TriangularView<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3> const, -1, -1, false> const, 2u>::solveInPlace<1, Eigen::Block<Eigen::Matrix<double, 3, 1, 0, 3, 1>, -1, 1, false>>(Eigen::MatrixBase<Eigen::Block<Eigen::Matrix<double, 3, 1, 0, 3, 1>, -1, 1, false>> const&) const
void TriangularView<MatrixType,Mode>::solveInPlace(const MatrixBase<OtherDerived>& _other) const
{
  OtherDerived& other = _other.const_cast_derived();
  eigen_assert( cols() == rows() && ((Side==OnTheLeft && cols() == other.rows()) || (Side==OnTheRight && cols() == other.cols())) );
  eigen_assert((!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));

  enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit  && OtherDerived::IsVectorAtCompileTime };
  typedef typename internal::conditional<copy,
    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
  OtherCopy otherCopy(other);

  internal::triangular_solver_selector<MatrixType, typename internal::remove_reference<OtherCopy>::type,
    Side, Mode>::run(nestedExpression(), otherCopy);

  if (copy)
    other = otherCopy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18bf90
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x18bfa0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x18bfc0
movq -0x30(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
jne 0x18bf40
movq -0x38(%rbp), %rdi
callq 0x18bfa0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x186cb0
movq -0x48(%rbp), %rcx
movq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x39(%rbp)
je 0x18bf3a
xorl %eax, %eax
movb %al, -0x39(%rbp)
jmp 0x18bf3a
movb -0x39(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x18bf49
jmp 0x18bf4b
jmp 0x18bf6a
leaq 0x7b79b(%rip), %rdi     # 0x2076ed
leaq 0x7b806(%rip), %rsi     # 0x20775f
movl $0xb1, %edx
leaq 0x7b81d(%rip), %rcx     # 0x207782
callq 0x5320
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x18c2f0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x18bfe0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/./Eigen/src/Core/SelfCwiseBinaryOp.h
// Function: void Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_difference_op<double>, Eigen::Map<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0, Eigen::Stride<0, 0>>, Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const>>::copyPacket<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const>, 1, 0>(long, Eigen::DenseBase<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const>> const&)
void copyPacket(Index index, const DenseBase<OtherDerived>& other)
    {
      OtherDerived& _other = other.const_cast_derived();
      eigen_internal_assert(index >= 0 && index < m_matrix.size());
      m_matrix.template writePacket<StoreMode>(index,
        m_functor.packetOp(m_matrix.template packet<StoreMode>(index),_other.template packet<LoadMode>(index)) );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1901c0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rcx
movq %rcx, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x68(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x190390
movapd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1903e0
movq -0x68(%rbp), %rdi
movapd %xmm0, -0x50(%rbp)
leaq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x190360
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movapd %xmm0, -0x30(%rbp)
leaq -0x30(%rbp), %rdx
callq 0x190300
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Luthaf[P]zeopp/./zeojobs.h
// Function: zeoJob::zeoJob()
zeoJob()
   {
   setupErrorFlag = false;
   probeRadiusFlag = false;
   volumeRunFlag = false;
   extendedOutputFlag = false;
   nMCsamplesScaleFactorFlag = false;
   nMCsamplesScaleFactor = 1.0;
   nMCAVsampleDensity = MCAVppA3; // use defauls from zeo_consts.h
   nMCASAsampleDensity = MCASAppA2; 
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
movq %rdi, -0x28(%rbp)
callq 0x19f950
movq -0x20(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0x1a7150
jmp 0x19fa63
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb $0x0, 0x228(%rax)
movb $0x0, 0x229(%rax)
movb $0x0, 0x244(%rax)
movb $0x0, 0x238(%rax)
movsd 0x525c2(%rip), %xmm0    # 0x1f2050
movsd %xmm0, 0x230(%rax)
movl $0xc8, 0x23c(%rax)
movl $0x32, 0x240(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x1a0eb0
movq -0x10(%rbp), %rdi
callq 0x58f0
nop
// File: Luthaf[P]zeopp/./material.h
// Function: MATERIAL::deinit()
void deinit()
   {
   accessAnalysis.deconstruct();
   //FREE MEMORY
   delete rad_con;
   delete no_rad_con;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x990, %rdi            # imm = 0x990
callq 0x1a9440
movq -0x18(%rbp), %rax
movq 0xc10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1a940c
movq -0x10(%rbp), %rdi
callq 0xece0
movq -0x10(%rbp), %rdi
movl $0x298, %esi            # imm = 0x298
callq 0x5570
movq -0x18(%rbp), %rax
movq 0xc18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1a9438
movq -0x20(%rbp), %rdi
callq 0xed10
movq -0x20(%rbp), %rdi
movl $0x270, %esi            # imm = 0x270
callq 0x5570
addq $0x20, %rsp
popq %rbp
retq
nop
// File: travisdowns[P]sort-bench/bench.cpp
// Function: is_sorted(unsigned long const*, unsigned long)
bool is_sorted(const uint64_t* p, size_t size) {
  for (size_t i = 0; i + 1 < size; i++) {
    if (p[i] > p[i + 1]) {
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
jae 0x2483
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
cmpq 0x8(%rcx,%rdx,8), %rax
jbe 0x2473
movb $0x0, -0x1(%rbp)
jmp 0x2487
jmp 0x2475
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2444
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop