LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: void Eigen::internal::generic_product_impl<Eigen::CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2> const> const>, Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2>, Eigen::DenseShape, Eigen::DenseShape, 8>::evalTo<Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>>(Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>&, Eigen::CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2> const> const> const&, Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2> const&)
static void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
  {
    if((rhs.rows()+dst.rows()+dst.cols())<20 && rhs.rows()>0)
      lazyproduct::evalTo(dst, lhs, rhs);
    else
    {
      dst.setZero();
      scaleAndAddTo(dst, lhs, rhs, Scalar(1));
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %rax
leaq -0x1(%rax), %rcx
cmpq $0xe, %rcx
ja 0x11b99
movq (%rsi), %rcx
cmpq %rax, 0x8(%rcx)
jne 0x11bd9
movq %rsp, %r14
movq %rcx, (%r14)
movq %rdx, 0x10(%r14)
movq (%rcx), %rsi
movq %rsi, 0x28(%r14)
movq 0x8(%rcx), %rcx
movq %rcx, 0x30(%r14)
movq (%rdx), %rdx
movq %rdx, 0x38(%r14)
movq %rax, 0x40(%r14)
movq %rcx, 0x48(%r14)
addq $0x8, %rbx
xorl %r15d, %r15d
movq %rbx, %r13
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x11d60
movsd %xmm0, -0x8(%r13)
movsd %xmm1, (%r13)
incq %r12
addq $0x10, %r13
cmpq $0x1, %r12
je 0x11b60
leaq 0x1(%r15), %rax
addq $0x20, %rbx
testq %r15, %r15
movq %rax, %r15
je 0x11b5a
jmp 0x11bcb
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rsp, %rcx
movq %rax, (%rcx)
movq $0x0, 0x8(%rcx)
movq %rbx, %rdi
callq 0x11bf8
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xe021(%rip), %rdi      # 0x1fc01
leaq 0xe0a6(%rip), %rsi      # 0x1fc8d
leaq 0x10d30(%rip), %rcx     # 0x2291e
movl $0x61, %edx
callq 0x31b0
// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/KroneckerProduct/KroneckerTensorProduct.h
// Function: void Eigen::KroneckerProduct<Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>, Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>>::evalTo<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>(Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>&) const
void KroneckerProduct<Lhs,Rhs>::evalTo(Dest& dst) const
{
  const int BlockRows = Rhs::RowsAtCompileTime,
            BlockCols = Rhs::ColsAtCompileTime;
  const Index Br = m_B.rows(),
              Bc = m_B.cols();
  for (Index i=0; i < m_A.rows(); ++i)
    for (Index j=0; j < m_A.cols(); ++j)
      Block<Dest,BlockRows,BlockCols>(dst,i*Br,j*Bc,Br,Bc) = m_A.coeff(i,j) * m_B;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x10, %eax
xorl %ecx, %ecx
movsd 0x972f(%rip), %xmm0     # 0x1d3f0
leaq (%rcx,%rcx), %rdx
movq %rcx, %r8
shlq $0x4, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movq 0x8(%rsi), %r11
leaq -0x2(%r11), %rbx
cmpq %rdx, %rbx
jl 0x13db7
leaq (%r10,%r10), %rbx
movq 0x10(%rsi), %r14
addq $-0x2, %r14
cmpq %rbx, %r14
jl 0x13db7
movq %r10, %r14
shlq $0x5, %r14
addq (%rdi), %r14
movq 0x8(%rdi), %rbx
movdqu (%r8,%r14), %xmm2
pshufd $0x44, %xmm2, %xmm1     # xmm1 = xmm2[0,1,0,1]
pshufd $0xee, %xmm2, %xmm2     # xmm2 = xmm2[2,3,2,3]
movq %r11, %r14
imulq %r9, %r14
movq (%rsi), %r15
addq %rax, %r15
shlq $0x4, %r11
xorl %r12d, %r12d
movupd (%rbx,%r12), %xmm3
movapd %xmm3, %xmm4
mulpd %xmm1, %xmm4
shufpd $0x1, %xmm3, %xmm3      # xmm3 = xmm3[1,0]
mulpd %xmm2, %xmm3
xorpd %xmm0, %xmm3
addpd %xmm4, %xmm3
movupd %xmm3, -0x10(%r15,%r14)
movupd 0x10(%rbx,%r12), %xmm3
movapd %xmm3, %xmm4
mulpd %xmm1, %xmm4
shufpd $0x1, %xmm3, %xmm3      # xmm3 = xmm3[1,0]
mulpd %xmm2, %xmm3
xorpd %xmm0, %xmm3
addpd %xmm4, %xmm3
movupd %xmm3, (%r15,%r14)
addq $0x20, %r12
addq %r11, %r15
cmpq $0x20, %r12
je 0x13d2a
leaq 0x1(%r10), %r11
addq $0x20, %r9
testq %r10, %r10
movq %r11, %r10
je 0x13cd2
leaq 0x1(%rcx), %rdx
addq $0x20, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x13cc1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xf247(%rip), %rdi      # 0x23005
leaq 0xa1e3(%rip), %rsi      # 0x1dfa8
leaq 0xf161(%rip), %rcx      # 0x22f2d
movl $0x93, %edx
callq 0x31b0
// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/LU/InverseImpl.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, Eigen::Inverse<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>, Eigen::internal::assign_op<std::complex<double>, std::complex<double>>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>&, Eigen::Inverse<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>> const&, Eigen::internal::assign_op<std::complex<double>, std::complex<double>> const&)
static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar> &)
  {
    Index dstRows = src.rows();
    Index dstCols = src.cols();
    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
      dst.resize(dstRows, dstCols);
    
    const int Size = EIGEN_PLAIN_ENUM_MIN(XprType::ColsAtCompileTime,DstXprType::ColsAtCompileTime);
    EIGEN_ONLY_USED_FOR_DEBUG(Size);
    eigen_assert(( (Size<=1) || (Size>4) || (extract_data(src.nestedExpression())!=extract_data(dst)))
              && "Aliasing problem detected in inverse(), you need to do inverse().eval() here.");

    typedef typename internal::nested_eval<XprType,XprType::ColsAtCompileTime>::type  ActualXprType;
    typedef typename internal::remove_all<ActualXprType>::type                        ActualXprTypeCleanded;
    
    ActualXprType actual_xpr(src.nestedExpression());
    
    compute_inverse<ActualXprTypeCleanded, DstXprType>::run(actual_xpr, dst);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rax), %r8
movq 0x10(%rax), %rcx
cmpq %r8, 0x8(%rdi)
jne 0x1426b
cmpq %rcx, 0x10(%rbx)
je 0x142a9
movq %rcx, %rax
orq %r8, %rax
js 0x142bb
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x14297
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x142da
movq %rcx, %rsi
imulq %r8, %rsi
movq %rbx, %rdi
movq %r8, %rdx
callq 0x630a
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14308
leaq 0x83d0(%rip), %rdi      # 0x1c692
leaq 0x8558(%rip), %rsi      # 0x1c821
leaq 0x8574(%rip), %rcx      # 0x1c844
movl $0x11d, %edx            # imm = 0x11D
callq 0x31b0
movl $0x8, %edi
callq 0x3130
movq 0x1acd5(%rip), %rcx     # 0x2efc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1acd7(%rip), %rsi     # 0x2efd0
movq 0x1aca8(%rip), %rdx     # 0x2efa8
movq %rax, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/LU/PartialPivLU.h
// Function: Eigen::PartialPivLU<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>::compute()
void PartialPivLU<MatrixType>::compute()
{
  check_template_parameters();

  // the row permutation is stored as int indices, so just to be sure:
  eigen_assert(m_lu.rows()<NumTraits<int>::highest());

  m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();

  eigen_assert(m_lu.rows() == m_lu.cols() && "PartialPivLU is only for square (and moreover invertible) matrices");
  const Index size = m_lu.rows();

  m_rowsTranspositions.resize(size);

  typename TranspositionType::StorageIndex nb_transpositions;
  internal::partial_lu_inplace(m_lu, m_rowsTranspositions, nb_transpositions);
  m_det_p = (nb_transpositions%2) ? -1 : 1;

  m_p = m_rowsTranspositions;

  m_isInitialized = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpq $0x7fffffff, 0x8(%rdi)  # imm = 0x7FFFFFFF
jge 0x1469b
movq %rdi, %rbx
movq %rdi, 0x38(%rsp)
cmpq $0x0, 0x10(%rdi)
jle 0x146ba
leaq 0x10(%rsp), %r14
movq %rbx, (%r14)
leaq 0x30(%rsp), %rax
movq %rax, 0x18(%r14)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x14764
movapd %xmm0, %xmm1
movq 0x18(%r14), %rax
movq 0x8(%rax), %rax
cmpq $0x2, 0x10(%rax)
jl 0x1462e
movl $0x1, %r14d
leaq 0x10(%rsp), %r15
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x14764
maxsd 0x8(%rsp), %xmm0
incq %r14
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movapd %xmm0, %xmm1
cmpq 0x10(%rax), %r14
jl 0x145fd
jmp 0x14632
movapd %xmm1, %xmm0
movsd %xmm0, 0x38(%rbx)
movq 0x8(%rbx), %rdx
cmpq 0x10(%rbx), %rdx
jne 0x146d9
testq %rdx, %rdx
js 0x146f8
leaq 0x28(%rbx), %r14
movl $0x1, %ecx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x67b2
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x14717
movb (%r15), %al
andb $0x1, %al
negb %al
orb $0x1, %al
movb %al, 0x40(%rbx)
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x190ce
movb $0x1, 0x41(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf507(%rip), %rdi      # 0x23ba9
leaq 0xf526(%rip), %rsi      # 0x23bcf
leaq 0xf53d(%rip), %rcx      # 0x23bed
movl $0x208, %edx            # imm = 0x208
callq 0x31b0
leaq 0xa018(%rip), %rdi      # 0x1e6d9
leaq 0xa055(%rip), %rsi      # 0x1e71d
leaq 0xf60d(%rip), %rcx      # 0x23cdc
movl $0x19d, %edx            # imm = 0x19D
callq 0x31b0
leaq 0xf599(%rip), %rdi      # 0x23c79
leaq 0xf4e8(%rip), %rsi      # 0x23bcf
leaq 0xf4ff(%rip), %rcx      # 0x23bed
movl $0x20c, %edx            # imm = 0x20C
callq 0x31b0
leaq 0x9d40(%rip), %rdi      # 0x1e43f
leaq 0x811b(%rip), %rsi      # 0x1c821
leaq 0xf430(%rip), %rcx      # 0x23b3d
movl $0x138, %edx            # imm = 0x138
callq 0x31b0
// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/LU/PartialPivLU.h
// Function: void Eigen::internal::partial_lu_inplace<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, Eigen::Transpositions<-1, -1, int>>(Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>&, Eigen::Transpositions<-1, -1, int>&, Eigen::Transpositions<-1, -1, int>::StorageIndex&)
void partial_lu_inplace(MatrixType& lu, TranspositionType& row_transpositions, typename TranspositionType::StorageIndex& nb_transpositions)
{
  eigen_assert(lu.cols() == row_transpositions.size());
  eigen_assert((&row_transpositions.coeffRef(1)-&row_transpositions.coeffRef(0)) == 1);

  partial_lu_impl
    <typename MatrixType::Scalar, MatrixType::Flags&RowMajorBit?RowMajor:ColMajor, typename TranspositionType::StorageIndex>
    ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions);
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq 0x10(%rdi), %rsi
cmpq 0x8(%rax), %rsi
jne 0x14744
movq %rdx, %r9
movq (%rax), %r8
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq $0x100, (%rsp)          # imm = 0x100
movq %rcx, %rdi
callq 0x1483e
popq %rax
retq
leaq 0xfafb(%rip), %rdi      # 0x24246
leaq 0xf47d(%rip), %rsi      # 0x23bcf
leaq 0xfb14(%rip), %rcx      # 0x2426d
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x31b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/Core/Visitor.h
// Function: void Eigen::DenseBase<Eigen::CwiseUnaryOp<Eigen::internal::scalar_score_coeff_op<std::complex<double>>, Eigen::Block<Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>, -1, -1, false>, -1, 1, true>, -1, 1, false> const>>::visit<Eigen::internal::max_coeff_visitor<Eigen::CwiseUnaryOp<Eigen::internal::scalar_score_coeff_op<std::complex<double>>, Eigen::Block<Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>, -1, -1, false>, -1, 1, true>, -1, 1, false> const>>>(Eigen::internal::max_coeff_visitor<Eigen::CwiseUnaryOp<Eigen::internal::scalar_score_coeff_op<std::complex<double>>, Eigen::Block<Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>, -1, -1, false>, -1, 1, true>, -1, 1, false> const>>&) const
EIGEN_DEVICE_FUNC
void DenseBase<Derived>::visit(Visitor& visitor) const
{
  typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
  ThisEvaluator thisEval(derived());
  
  enum {
    unroll =  SizeAtCompileTime != Dynamic
           && SizeAtCompileTime * ThisEvaluator::CoeffReadCost + (SizeAtCompileTime-1) * internal::functor_traits<Visitor>::Cost <= EIGEN_UNROLLING_LIMIT
  };
  return internal::visitor_impl<Visitor, ThisEvaluator, unroll ? int(SizeAtCompileTime) : Dynamic>::run(thisEval, visitor);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
callq 0x3490
movsd %xmm0, 0x10(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
cmpq $0x2, 0x8(%r14)
jl 0x15ed9
addq $0x18, %r15
movl $0x1, %r12d
movsd -0x8(%r15), %xmm0
movsd (%r15), %xmm1
callq 0x3490
ucomisd 0x10(%rbx), %xmm0
jbe 0x15ecc
movsd %xmm0, 0x10(%rbx)
movq %r12, (%rbx)
movq $0x0, 0x8(%rbx)
incq %r12
addq $0x10, %r15
cmpq 0x8(%r14), %r12
jl 0x15ea5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: Eigen::internal::gemm_functor<std::complex<double>, long, Eigen::internal::general_matrix_matrix_product<long, std::complex<double>, 0, false, std::complex<double>, 0, false, 0>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>, -1, -1, false>, -1, -1, false>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>, -1, -1, false>, -1, -1, false>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>, -1, -1, false>, -1, -1, false>, Eigen::internal::gemm_blocking_space<0, std::complex<double>, std::complex<double>, -1, -1, -1, 1, false>>::operator()(long, long, long, long, Eigen::internal::GemmParallelInfo<long>*) const
void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
  {
    if(cols==-1)
      cols = m_rhs.cols();

    Gemm::run(rows, cols, m_lhs.cols(),
              &m_lhs.coeffRef(row,0), m_lhs.outerStride(),
              &m_rhs.coeffRef(0,col), m_rhs.outerStride(),
              (Scalar*)&(m_dest.coeffRef(row,col)), m_dest.outerStride(),
              m_actualAlpha, m_blocking, info);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r10
movq %r8, %r14
movq %rcx, %rax
movq %rdx, %rbx
movq %rdi, %r11
cmpq $-0x1, %r8
jne 0x18aef
movq 0x8(%r11), %rcx
movq 0x10(%rcx), %r14
shlq $0x4, %rsi
movq (%r11), %rdi
movq 0x8(%r11), %r8
movq (%rdi), %rcx
addq %rsi, %rcx
movq 0x10(%rdi), %rdx
movq 0x78(%r8), %r15
movq %r15, %r9
imulq %rax, %r9
shlq $0x4, %r9
addq (%r8), %r9
movq 0x10(%r11), %r8
movq 0x78(%r8), %r12
imulq %r12, %rax
shlq $0x4, %rax
addq (%r8), %rax
movq 0x78(%rdi), %r8
addq %rsi, %rax
movsd 0x18(%r11), %xmm0
movsd 0x20(%r11), %xmm1
subq $0x8, %rsp
movq %rbx, %rdi
movq %r14, %rsi
pushq %r10
pushq 0x28(%r11)
pushq %r12
pushq %rax
pushq %r15
callq 0x18b62
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/Core/PermutationMatrix.h
// Function: Eigen::PermutationMatrix<-1, -1, int>& Eigen::PermutationBase<Eigen::PermutationMatrix<-1, -1, int>>::operator=<Eigen::Transpositions<-1, -1, int>>(Eigen::TranspositionsBase<Eigen::Transpositions<-1, -1, int>> const&)
Derived& operator=(const TranspositionsBase<OtherDerived>& tr)
    {
      setIdentity(tr.size());
      for(Index k=size()-1; k>=0; --k)
        applyTranspositionOnTheRight(k,tr.coeff(k));
      return derived();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x1911a
movq 0x8(%rbx), %r15
testq %r15, %r15
jle 0x19110
decq %r15
movq (%r14), %rax
movslq (%rax,%r15,4), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1916e
leaq -0x1(%r15), %rax
incq %r15
cmpq $0x1, %r15
movq %rax, %r15
jg 0x190ee
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/Core/CoreEvaluators.h
// Function: Eigen::internal::Packet1cd const Eigen::internal::product_evaluator<Eigen::Product<Eigen::Inverse<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>, Eigen::Matrix<std::complex<double>, 4, 1, 0, 4, 1>, 1>, 3, Eigen::DenseShape, Eigen::DenseShape, std::complex<double>, std::complex<double>>::packet<0, Eigen::internal::Packet1cd>(long, long) const
EIGEN_STRONG_INLINE
  PacketType packet(Index row, Index col) const
  {
    if (IsRowMajor)
      return ploadt<PacketType, LoadMode>(m_data + row * m_outerStride.value() + col);
    else
      return ploadt<PacketType, LoadMode>(m_data + row + col * m_outerStride.value());
  }

// Assembly:
shlq $0x4, %rsi
movq 0x20(%rdi), %rdx
movq 0x28(%rdi), %rcx
leaq (%rdx,%rsi), %rax
movq 0x30(%rdi), %rdi
movupd (%rdx,%rsi), %xmm2
movapd %xmm2, %xmm5
unpcklpd %xmm2, %xmm5            # xmm5 = xmm5[0],xmm2[0]
movupd (%rdi), %xmm4
movupd 0x10(%rdi), %xmm3
movupd 0x20(%rdi), %xmm1
movupd 0x30(%rdi), %xmm0
mulpd %xmm4, %xmm5
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
shufpd $0x1, %xmm4, %xmm4      # xmm4 = xmm4[1,0]
mulpd %xmm2, %xmm4
movsd 0x2bb5(%rip), %xmm2     # 0x1d3f0
xorpd %xmm2, %xmm4
addpd %xmm5, %xmm4
movq %rcx, %rdx
shlq $0x4, %rdx
movupd (%rdx,%rax), %xmm5
movapd %xmm5, %xmm6
unpcklpd %xmm5, %xmm6            # xmm6 = xmm6[0],xmm5[0]
mulpd %xmm3, %xmm6
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
shufpd $0x1, %xmm3, %xmm3      # xmm3 = xmm3[1,0]
mulpd %xmm5, %xmm3
xorpd %xmm2, %xmm3
addpd %xmm6, %xmm3
addpd %xmm4, %xmm3
leaq (%rcx,%rcx,2), %rdx
shlq $0x5, %rcx
movupd (%rcx,%rax), %xmm4
movapd %xmm4, %xmm5
unpcklpd %xmm4, %xmm5            # xmm5 = xmm5[0],xmm4[0]
mulpd %xmm1, %xmm5
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
shufpd $0x1, %xmm1, %xmm1      # xmm1 = xmm1[1,0]
mulpd %xmm4, %xmm1
xorpd %xmm2, %xmm1
addpd %xmm5, %xmm1
addpd %xmm3, %xmm1
shlq $0x4, %rdx
movupd (%rdx,%rax), %xmm3
movapd %xmm3, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
mulpd %xmm0, %xmm4
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
shufpd $0x1, %xmm0, %xmm0      # xmm0 = xmm0[1,0]
mulpd %xmm3, %xmm0
xorpd %xmm2, %xmm0
addpd %xmm4, %xmm0
addpd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/main.cc
// Function: main
int main(int argc, char * argv[])
{
    if(argc < 3)
        printf("ERROR: Not enough arguments.\n");
    else
    {
        Mesh m;

        m.generateHalfEdge(argv[1]);

        int count = atoi(argv[2]);

        auto s1 = std::chrono::high_resolution_clock::now();
        for(int i = 0; i < count; i++)
        {
            auto t1 = std::chrono::high_resolution_clock::now();
            m.subdivide();
            auto t2 = std::chrono::high_resolution_clock::now();
            double duration = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count() * 0.000000001;
            printf("Subdiv number %d took: %f seconds\n", i + 1, duration);
        }
        auto s2 = std::chrono::high_resolution_clock::now();
        double duration = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(s2 - s1).count() * 0.000000001;
        printf("All subdivs took: %f seconds\n", duration);
        
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpl $0x2, %edi
jg 0x2490
leaq 0x3bcb(%rip), %rdi      # 0x6051
callq 0x2230
jmp 0x2552
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x257c
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x2646
movq 0x10(%rbx), %rdi
callq 0x2240
movl %eax, %r14d
callq 0x2060
movq %rax, %rbx
testl %r14d, %r14d
jle 0x2522
negl %r14d
movl $0x1, %r13d
leaq 0x8(%rsp), %r15
leaq 0x3b36(%rip), %r12      # 0x6010
callq 0x2060
movq %rax, %rbp
movq %r15, %rdi
callq 0x4076
callq 0x2060
subq %rbp, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x3b06(%rip), %xmm0     # 0x6008
movq %r12, %rdi
movl %r13d, %esi
movb $0x1, %al
callq 0x2050
leal (%r14,%r13), %eax
incl %eax
movl %r13d, %ecx
incl %ecx
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0x24da
callq 0x2060
subq %rbx, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x3ace(%rip), %xmm0     # 0x6008
leaq 0x3af2(%rip), %rdi      # 0x6033
movb $0x1, %al
callq 0x2050
leaq 0x8(%rsp), %rdi
callq 0x2598
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2565
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2598
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::facePoint(HEFace*)
HEVert* Mesh::facePoint(HEFace *face)
{

    if(face->avg != nullptr)
        return face->avg;

    HEVert *fp = vertPool.new_element();
    
    HEEdge* temp = face->edge->next;

    fp->pos = v3(0, 0, 0);
    
    while(true)
    {

        fp->pos = fp->pos + temp->vert->pos;

        if(temp == face->edge)
            break;
        temp = temp->next;
    }

    fp->pos = fp->pos * 0.25f;
    
    face->avg = fp;
    return face->avg;
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3bae
retq
pushq %rbx
movq %rsi, %rbx
addq $0x20, %rdi
callq 0x492e
movq (%rbx), %rcx
movq 0x18(%rcx), %rdx
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movq (%rdx), %rsi
xorps %xmm0, %xmm0
movss (%rsi), %xmm1
addss %xmm0, %xmm1
movss 0x4(%rsi), %xmm2
addss %xmm0, %xmm2
addss 0x8(%rsi), %xmm0
movss %xmm1, (%rax)
movss %xmm2, 0x4(%rax)
movss %xmm0, 0x8(%rax)
cmpq %rcx, %rdx
je 0x3c11
movq 0x18(%rdx), %rdx
movq (%rdx), %rsi
addss (%rsi), %xmm1
addss 0x4(%rsi), %xmm2
jmp 0x3be7
movss 0x2467(%rip), %xmm3     # 0x6080
mulss %xmm3, %xmm1
mulss %xmm3, %xmm2
mulss %xmm3, %xmm0
movss %xmm1, (%rax)
movss %xmm2, 0x4(%rax)
movss %xmm0, 0x8(%rax)
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::edgePoint(HEEdge*)
HEVert* Mesh::edgePoint(HEEdge *edge)
{

    if(edge->ePt != nullptr)
        return edge->ePt;

    if(edge->pair->ePt != nullptr)
        return edge->pair->ePt;

    HEVert *newV = vertPool.new_element();
    
    HEVert *fp1 = facePoint(edge->face);
    HEVert *fp2 = facePoint(edge->pair->face);
    
    newV->pos = (edge->vert->pos + edge->next->vert->pos + fp1->pos + fp2->pos) * 0.25f;

    edge->ePt = newV;
    
    return edge->ePt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rsi), %r14
testq %r14, %r14
jne 0x3d02
movq %rsi, %rbx
movq 0x8(%rsi), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
jne 0x3d02
movq %rdi, %r15
addq $0x20, %rdi
callq 0x492e
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x3ba4
movq %rax, %r12
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x3ba4
movq (%rbx), %rcx
movq 0x18(%rbx), %rdx
movq (%rdx), %rdx
movss (%rdx), %xmm0
movss 0x4(%rdx), %xmm1
addss (%rcx), %xmm0
addss 0x4(%rcx), %xmm1
movss 0x8(%rdx), %xmm2
addss 0x8(%rcx), %xmm2
addss (%r12), %xmm0
addss 0x4(%r12), %xmm1
addss 0x8(%r12), %xmm2
addss (%rax), %xmm0
addss 0x4(%rax), %xmm1
addss 0x8(%rax), %xmm2
movss 0x239f(%rip), %xmm3     # 0x6080
mulss %xmm3, %xmm0
mulss %xmm3, %xmm1
mulss %xmm3, %xmm2
movss %xmm0, (%r14)
movss %xmm1, 0x4(%r14)
movss %xmm2, 0x8(%r14)
movq %r14, 0x20(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::splitEdge(HEEdge*)
void Mesh::splitEdge(HEEdge *edge)
{

    if(edge->split)
        return;

    edge->split = true;
    edge->pair->split = true;
    
    HEEdge *newEdge = edgePool.new_element();
    HEEdge *newPairEdge = edgePool.new_element();
    
    newEdge->split = true;
    newPairEdge->split = true;

    newEdge->uv = (edge->uv + edge->next->uv) * 0.5f;
    newPairEdge->uv = (edge->pair->uv + edge->pair->next->uv) * 0.5f;
    
    HEVert *v = edgePoint(edge);
    
    newEdge->next = edge->next;
    newEdge->pair = edge->pair;
    newEdge->vert = v;
    newEdge->vert->edge = newEdge;
    newEdge->face = edge->face;
    
    newPairEdge->next = edge->pair->next;
    newPairEdge->pair = edge->pair->pair;
    newPairEdge->vert = v;
    newPairEdge->vert->edge = newPairEdge;
    newPairEdge->face = edge->pair->face;
    
    edge->pair->pair = newEdge;
    edge->pair->next = newPairEdge;
    edge->pair = newPairEdge;
    edge->next = newEdge;

    edge->ePt = nullptr;
    newEdge->pair->ePt = nullptr;


}

// Assembly:
cmpb $0x0, 0x3c(%rsi)
jne 0x3e7f
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r12
movb $0x1, %bpl
movb %bpl, 0x3c(%rsi)
movq 0x8(%rsi), %rax
movb %bpl, 0x3c(%rax)
callq 0x4ab8
movq %rax, %r14
movq %r12, %rdi
callq 0x4ab8
movq %rax, %r15
movb %bpl, 0x3c(%r14)
movb %bpl, 0x3c(%rax)
movq 0x18(%rbx), %rax
movss 0x28(%rbx), %xmm0
addss 0x28(%rax), %xmm0
movss 0x2c(%rbx), %xmm1
addss 0x2c(%rax), %xmm1
movss 0x22c4(%rip), %xmm2     # 0x6084
mulss %xmm2, %xmm0
mulss %xmm2, %xmm1
movss %xmm0, 0x28(%r14)
movss %xmm1, 0x2c(%r14)
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rcx
movss 0x28(%rax), %xmm0
addss 0x28(%rcx), %xmm0
movss 0x2c(%rax), %xmm1
addss 0x2c(%rcx), %xmm1
mulss %xmm2, %xmm0
mulss %xmm2, %xmm1
movss %xmm0, 0x28(%r15)
movss %xmm1, 0x2c(%r15)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3c3a
movq 0x18(%rbx), %rcx
movq %rcx, 0x18(%r14)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%r14)
movq %r14, 0x10(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%r14)
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%r15)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%r15)
movq %rax, (%r15)
movq %r15, 0x10(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r15)
movq %r14, 0x8(%rax)
movq 0x8(%rbx), %rax
movq %r15, 0x18(%rax)
movq %r15, 0x8(%rbx)
movq %r14, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movq 0x8(%r14), %rcx
movq %rax, 0x20(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::splitEdges(HEEdge*)
void Mesh::splitEdges(HEEdge *edge)
{

    HEEdge *temp;
    if(edge->next->split)
        temp = edge->next->next;
    else
        temp = edge->next;

    while(true)
    {
        splitEdge(temp);

        if(temp == edge)
            break;

        while(temp != edge && temp->split)
            temp = temp->next;

    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
cmpb $0x1, 0x3c(%r15)
jne 0x3eac
movq 0x18(%r15), %r15
jmp 0x3eac
cmpb $0x1, 0x3c(%r15)
jne 0x3eac
movq 0x18(%r15), %r15
cmpq %rbx, %r15
jne 0x3e9c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d5e
cmpq %rbx, %r15
jne 0x3e9c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::newVertex(HEVert*)
v3 Mesh::newVertex(HEVert *vert)
{
    
    HEEdge* temp = vert->edge->pair->next;

    int n = 0;

    v3 avgFace(0, 0, 0);
    v3 avgAvg(0, 0, 0);
    
    while(true)
    {
        n++;
        avgFace = avgFace + edgePoint(temp)->pos;
        avgAvg = avgAvg + avgPoint(temp);

        if(temp == vert->edge)
            break;
        temp = temp->pair->next;
    }

    float ndiv = 1.f/(float)n;
    
    avgFace = avgFace * ndiv;
    avgAvg = avgAvg * ndiv;

    v3 res;
    
    res = (avgFace * ndiv) + ((avgAvg*2) * ndiv) + (vert->pos*(n - 3) * ndiv);
    
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %r12
xorps %xmm5, %xmm5
movl $0xfffffffd, %r13d      # imm = 0xFFFFFFFD
xorps %xmm6, %xmm6
xorps %xmm4, %xmm4
xorps %xmm8, %xmm8
xorps %xmm7, %xmm7
xorps %xmm3, %xmm3
movss %xmm8, 0x8(%rsp)
movss %xmm7, 0xc(%rsp)
movss %xmm3, 0x10(%rsp)
movss %xmm6, 0x14(%rsp)
movss %xmm5, 0x18(%rsp)
movss %xmm4, 0x1c(%rsp)
movq 0x8(%r12), %rax
movq 0x18(%rax), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3c3a
movss 0x8(%rsp), %xmm8
movss 0xc(%rsp), %xmm7
movss 0x10(%rsp), %xmm3
movss 0x14(%rsp), %xmm6
movss 0x18(%rsp), %xmm5
movss 0x1c(%rsp), %xmm4
addss (%rax), %xmm8
addss 0x4(%rax), %xmm7
addss 0x8(%rax), %xmm3
movq (%r12), %rax
movq 0x18(%r12), %rcx
movq (%rcx), %rcx
movss (%rcx), %xmm0
movss 0x4(%rcx), %xmm1
addss (%rax), %xmm0
addss 0x4(%rax), %xmm1
movss 0x8(%rcx), %xmm2
addss 0x8(%rax), %xmm2
movss 0x20f1(%rip), %xmm9     # 0x6084
mulss %xmm9, %xmm0
addss %xmm0, %xmm5
mulss %xmm9, %xmm1
addss %xmm1, %xmm6
mulss %xmm9, %xmm2
addss %xmm2, %xmm4
incl %r13d
cmpq 0x10(%r14), %r12
jne 0x3ef5
leal 0x3(%r13), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss 0x20ba(%rip), %xmm0     # 0x6088
divss %xmm1, %xmm0
mulss %xmm0, %xmm8
mulss %xmm0, %xmm7
mulss %xmm0, %xmm3
mulss %xmm0, %xmm5
mulss %xmm0, %xmm6
mulss %xmm0, %xmm4
mulss %xmm0, %xmm8
mulss %xmm0, %xmm7
mulss %xmm0, %xmm3
addss %xmm5, %xmm5
addss %xmm6, %xmm6
addss %xmm4, %xmm4
mulss %xmm0, %xmm5
addss %xmm8, %xmm5
mulss %xmm0, %xmm6
addss %xmm7, %xmm6
mulss %xmm0, %xmm4
addss %xmm3, %xmm4
xorps %xmm1, %xmm1
cvtsi2ss %r13d, %xmm1
movss (%r14), %xmm2
mulss %xmm1, %xmm2
movss 0x4(%r14), %xmm3
mulss %xmm1, %xmm3
mulss 0x8(%r14), %xmm1
mulss %xmm0, %xmm2
addss %xmm5, %xmm2
mulss %xmm0, %xmm3
addss %xmm6, %xmm3
mulss %xmm0, %xmm1
addss %xmm4, %xmm1
movss %xmm2, (%rbx)
movss %xmm3, 0x4(%rbx)
movss %xmm1, 0x8(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::getVB()
v3* Mesh::getVB()
{
    v3* VB = new v3[fCount*eStep];
    for(int i = 0; i < fCount; i++)
    {

        HEEdge *temp = facePool[i]->edge;
        for(int j = 0; j < eStep; j++)
        {
            VB[i*eStep + j] = temp->vert->pos;
            
            temp = temp->next;
        }
    }
    return VB;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x60(%rdi), %r14
movl 0x64(%rdi), %r15d
movl %r15d, %eax
imull %r14d, %eax
cltq
movl $0xc, %ecx
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x2030
testq %r14, %r14
jle 0x468a
movl 0x5c(%rbx), %ecx
movq 0x40(%rbx), %rdx
leaq (,%r15,4), %rsi
leaq (%rsi,%rsi,2), %rsi
xorl %edi, %edi
movq %rax, %r8
cmpq %rcx, %rdi
je 0x4690
testl %r15d, %r15d
jle 0x467f
movl %edi, %r10d
shrl $0xa, %r10d
movl %edi, %r9d
andl $0x3ff, %r9d            # imm = 0x3FF
shll $0x4, %r9d
addq (%rdx,%r10,8), %r9
xorl %r10d, %r10d
movq (%r9), %r9
movq (%r9), %r11
movl 0x8(%r11), %ebx
movl %ebx, 0x8(%r8,%r10)
movq (%r11), %r11
movq %r11, (%r8,%r10)
addq $0x18, %r9
addq $0xc, %r10
cmpq %r10, %rsi
jne 0x465c
incq %rdi
addq %rsi, %r8
cmpq %r14, %rdi
jne 0x4636
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x1a7a(%rip), %rsi      # 0x611e
movq %rax, %rdi
callq 0x2070
movq 0x4925(%rip), %rsi      # 0x8fd8
movq 0x4916(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::getUV()
v2* Mesh::getUV()
{
    v2* UV = new v2[fCount*eStep];
    for(int i = 0; i < fCount; i++)
    {

        HEEdge *temp = facePool[i]->edge;
        for(int j = 0; j < eStep; j++)
        {
            UV[i*eStep + j] = temp->uv;
 
            temp = temp->next;
        }
    }
    return UV;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x60(%rdi), %r14
movl 0x64(%rdi), %r15d
movl %r15d, %eax
imull %r14d, %eax
cltq
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
testq %r14, %r14
jle 0x476a
movl 0x5c(%rbx), %ecx
movq 0x40(%rbx), %rdx
leaq (,%r15,8), %rsi
xorl %edi, %edi
movq %rax, %r8
cmpq %rcx, %rdi
je 0x4770
testl %r15d, %r15d
jle 0x475f
movl %edi, %r10d
shrl $0xa, %r10d
movl %edi, %r9d
andl $0x3ff, %r9d            # imm = 0x3FF
shll $0x4, %r9d
addq (%rdx,%r10,8), %r9
xorl %r10d, %r10d
movq (%r9), %r9
movq 0x28(%r9), %r11
movq %r11, (%r8,%r10,8)
addq $0x18, %r9
incq %r10
cmpq %r10, %r15
jne 0x4748
incq %rdi
addq %rsi, %r8
cmpq %r14, %rdi
jne 0x4722
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x199a(%rip), %rsi      # 0x611e
movq %rax, %rdi
callq 0x2070
movq 0x4845(%rip), %rsi      # 0x8fd8
movq 0x4836(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::getNormals()
v3* Mesh::getNormals()
{
    v3* N = new v3[fCount*eStep];
    for(int i = 0; i < fCount; i++)
    {

        HEEdge *temp = facePool[i]->edge;
        for(int j = 0; j < eStep; j++)
        {
            N[i*eStep + j] = temp->norm;
            temp = temp->next;
        }
    }
    return N;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x60(%rdi), %r14
movl 0x64(%rdi), %r15d
movl %r15d, %eax
imull %r14d, %eax
cltq
movl $0xc, %ecx
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x2030
testq %r14, %r14
jle 0x4856
movl 0x5c(%rbx), %ecx
movq 0x40(%rbx), %rdx
leaq (,%r15,4), %rsi
leaq (%rsi,%rsi,2), %rsi
xorl %edi, %edi
movq %rax, %r8
cmpq %rcx, %rdi
je 0x485c
testl %r15d, %r15d
jle 0x484b
movl %edi, %r10d
shrl $0xa, %r10d
movl %edi, %r9d
andl $0x3ff, %r9d            # imm = 0x3FF
shll $0x4, %r9d
addq (%rdx,%r10,8), %r9
xorl %r10d, %r10d
movq (%r9), %r9
movl 0x38(%r9), %r11d
movl %r11d, 0x8(%r8,%r10)
movq 0x30(%r9), %r11
movq %r11, (%r8,%r10)
addq $0x18, %r9
addq $0xc, %r10
cmpq %r10, %rsi
jne 0x482a
incq %rdi
addq %rsi, %r8
cmpq %r14, %rdi
jne 0x4804
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x18ae(%rip), %rsi      # 0x611e
movq %rax, %rdi
callq 0x2070
movq 0x4759(%rip), %rsi      # 0x8fd8
movq 0x474a(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/eliebe-5[P]Catmull-clark-subdivision/./memorypool.h
// Function: Memorypool<HEEdge>::new_element()
inline T* Memorypool<T>::new_element()
{
	if (next_element*sizeof(T) >> BITSHIFT == nr_of_blocks)
		allocate_new_block();

	uint element = next_element;

	next_element++;
    
	return get_element_ref(element);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1c(%rdi), %eax
shrl $0x8, %eax
cmpl 0x18(%rdi), %eax
jne 0x4b23
movl $0x4000, %edi           # imm = 0x4000
callq 0x2030
xorl %ecx, %ecx
xorps %xmm0, %xmm0
movb $0x0, 0x3c(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movups %xmm0, 0x10(%rax,%rcx)
movq $0x0, 0x20(%rax,%rcx)
addq $0x40, %rcx
cmpq $0x4000, %rcx           # imm = 0x4000
jne 0x4ad9
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4b15
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4b20
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x538c
incl 0x18(%rbx)
movl 0x1c(%rbx), %ecx
movl %ecx, %eax
incl %eax
movl %eax, 0x1c(%rbx)
je 0x4b47
movzbl %cl, %eax
movq (%rbx), %rdx
shrl $0x8, %ecx
shll $0x6, %eax
addq (%rdx,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x15c3(%rip), %rsi      # 0x611e
movq %rax, %rdi
callq 0x2070
movq 0x446e(%rip), %rsi      # 0x8fd8
movq 0x445f(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/noizebox[P]zipfsong/zipfsong.cpp
// Function: parse_songs(int, std::vector<Song, std::allocator<Song>>&)
void parse_songs(int songs, std::vector<Song>& song_list)
{
    song_list.reserve(songs);
    std::string input;
    for (int i = 1 ; i <= songs ; i++)
    {
        std::getline(std::cin, input);
        int pos = input.find(" ");
        int64_t listens = atol(input.substr(0, pos).c_str());
        song_list.emplace_back(std::string_view(input).substr(pos + 1), listens * i);
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, (%rsp)
movslq %edi, %rbx
movq %rsi, 0x28(%rsp)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x2826
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
testl %ebx, %ebx
jle 0x24c8
movq (%rsp), %rax
incl %eax
movq %rax, (%rsp)
movl $0x1, %ebp
movq 0x5bfd(%rip), %r14      # 0x7fe0
leaq 0x8(%rsp), %r12
leaq 0x38(%rsp), %rbx
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
movl $0x1, %ecx
movq %r12, %rdi
leaq 0x2bef(%rip), %rsi      # 0x500d
xorl %edx, %edx
callq 0x21a0
movq %rax, %r13
movslq %r13d, %rcx
movq %r12, %rsi
movq %rbx, %r15
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2110
movq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x2130
movq %rax, %rbx
leaq 0x48(%rsp), %rax
cmpq %rax, %r14
je 0x2465
movq 0x48(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2100
shlq $0x20, %r13
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r13
movq 0x10(%rsp), %rcx
sarq $0x20, %r13
movq %rcx, %rax
subq %r13, %rax
jb 0x24f3
addq 0x8(%rsp), %r13
movq %rax, 0x38(%rsp)
movq %r13, 0x40(%rsp)
imulq %rbp, %rbx
movq %rbx, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movq %r15, %rbx
movq %r15, %rsi
leaq 0x30(%rsp), %rdx
callq 0x2906
incq %rbp
cmpq %rbp, (%rsp)
movq 0x5b1e(%rip), %r14      # 0x7fe0
jne 0x23ed
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x24e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2100
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b34(%rip), %rdi      # 0x502e
leaq 0x2b13(%rip), %rsi      # 0x5014
movq %r13, %rdx
xorl %eax, %eax
callq 0x2160
jmp 0x2511
jmp 0x2511
jmp 0x2511
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2530
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2100
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/eschwabe[P]interview-practice/src/stringpermutations.cpp
// Function: perm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
void perm(string str, size_t rotate) {
    if(str.size() <= rotate) {
        cout << str << endl;
    }
    else {
        for(size_t idx = rotate; idx < str.size(); idx++) {
            string rstr = str;
            char tmp = rstr[rotate];
            rstr[rotate] = rstr[idx];
            rstr[idx] = tmp;
            perm(rstr, rotate+1);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
cmpq %rsi, %rdx
jbe 0x2414
movq %rsi, %rbp
movq 0x8(%rbx), %rdx
cmpq %rsi, %rdx
jbe 0x2405
leaq 0x38(%rsp), %r12
leaq 0x1(%rbp), %r15
leaq 0x28(%rsp), %r13
movq %rbp, %r14
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rbx), %rsi
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2ab2
movq 0x8(%rsp), %rax
movb (%rax,%rbp), %cl
movb (%rax,%r14), %dl
movb %dl, (%rax,%rbp)
movq 0x8(%rsp), %rax
movb %cl, (%rax,%r14)
movq %r12, 0x28(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x2ab2
movq %r13, %rdi
movq %r15, %rsi
callq 0x232c
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x23d9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2120
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x23f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2120
incq %r14
movq 0x8(%rbx), %rdx
cmpq %rdx, %r14
jb 0x236b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rsi
movq 0x3bba(%rip), %rdi      # 0x5fd8
callq 0x2130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
movq %rax, %rbx
jmp 0x247a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x247a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2120
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2496
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2120
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/Falldog[P]dcinja/src/dcinja.cpp
// Function: read_source(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool read_source(std::string srcPath, std::string& content) {
    if (srcPath == "") {
        std::istream_iterator<char> it(std::cin >> std::noskipws);
        std::istream_iterator<char> end;
        content.assign(it, end);
    } else {
        std::ifstream fs(srcPath);
        if (!fs.good()) {
            std::cout << "can't find the file: " << srcPath << std::endl;
            exit(1);
        }
        fs.seekg(0, std::ios::end);
        size_t size = fs.tellg();
        std::string buffer(size, ' ');
        fs.seekg(0);
        fs.read(&buffer[0], size); 
        content = buffer;
    }
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4c7c6(%rip), %rsi     # 0x5697b
callq 0x90e0
testl %eax, %eax
je 0xa272
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x96f0
movq (%r15), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x58(%rsp,%rax)
jne 0xa2e5
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x95b0
leaq 0x38(%rsp), %rdi
callq 0x9760
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x20, %edx
callq 0x94c0
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x9530
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %r14, %rdx
callq 0x9510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x9220
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa266
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
leaq 0x38(%rsp), %rdi
callq 0x90c0
jmp 0xa2d6
movq 0x6ed57(%rip), %rax     # 0x78fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
andl $0xffffefff, 0x18(%rax,%rcx) # imm = 0xFFFFEFFF
leaq 0x28(%rsp), %r14
movq %rax, (%r14)
movb $0x1, 0x9(%r14)
movq %r14, %rdi
callq 0x493a4
movq (%r14), %rax
movzwl 0x8(%r14), %edi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
movw %di, 0x8(%rcx)
leaq 0x8(%rsp), %r8
movq $0x0, (%r8)
movw $0x0, 0x8(%r8)
movq %rbx, %rdi
callq 0x493d4
movb $0x1, %al
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r14
popq %r15
retq
movq 0x6ecac(%rip), %rdi     # 0x78f98
leaq 0x4c21f(%rip), %rsi     # 0x56512
movl $0x15, %edx
callq 0x9490
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x6ec8d(%rip), %rdi     # 0x78f98
callq 0x9490
movq %rax, %rdi
callq 0x91e0
movl $0x1, %edi
callq 0x94d0
jmp 0xa326
jmp 0xa326
movq %rax, %rbx
jmp 0xa345
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa345
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x93c0
leaq 0x38(%rsp), %rdi
callq 0x90c0
movq %rbx, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/Falldog[P]dcinja/src/dcinja.cpp
// Function: parse_delimiters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto parse_delimiters(const std::string& s) -> std::pair<std::string, std::string> {
    auto pos = s.find(' ');
    if (pos == std::string::npos) {
        return std::make_pair(s, s);
    }
    return std::make_pair(s.substr(0, pos), s.substr(pos + 1));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x9550
cmpq $-0x1, %rax
je 0xa3cb
movq %rax, %r15
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x9410
incq %r15
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x9410
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xa3db
movq %rdx, (%rbx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0xa3e1
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0xf812
jmp 0xa446
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x30(%rbx), %rcx
movq %rcx, 0x20(%rbx)
leaq 0x30(%rsp), %rdx
movq -0x10(%rdx), %rsi
cmpq %rdx, %rsi
je 0xa421
movq %rsi, 0x20(%rbx)
movq 0x30(%rsp), %rcx
movq %rcx, 0x30(%rbx)
jmp 0xa427
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movq 0x28(%rsp), %rcx
movq %rcx, 0x28(%rbx)
movq (%rsp), %rdi
cmpq %rax, %rdi
je 0xa446
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x93c0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa471
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x93c0
movq %rbx, %rdi
callq 0x9790
// File: /workspace/github_cpp_makefile_star2_O1/Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::merge_patch(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&)
void merge_patch(const basic_json& apply_patch)
    {
        if (apply_patch.is_object())
        {
            if (!is_object())
            {
                *this = object();
            }
            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
            {
                if (it.value().is_null())
                {
                    erase(it.key());
                }
                else
                {
                    operator[](it.key()).merge_patch(it.value());
                }
            }
        }
        else
        {
            *this = apply_patch;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0xeb85
cmpb $0x1, (%rbx)
je 0xeae4
leaq 0x18(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x4d1aa
movq %r15, %rdi
callq 0x2450a
movb (%rbx), %al
movb (%r15), %cl
movb %cl, (%rbx)
movb %al, (%r15)
leaq 0x20(%rsp), %r12
movq 0x8(%rbx), %rax
movq (%r12), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r12)
movq %rbx, %rdi
callq 0x2450a
movq %r15, %rdi
callq 0x2450a
movzbl -0x8(%r12), %esi
movq %r12, %rdi
callq 0x3c32c
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x37c68
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x37d1e
movq %r15, %rdi
movq %r12, %rsi
callq 0x37dc8
testb %al, %al
jne 0xebd7
leaq 0x48(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
callq 0x374c2
movb (%rax), %bpl
movq %r15, %rdi
callq 0x4d0ce
movq %rbx, %rdi
movq %rax, %rsi
testb %bpl, %bpl
je 0xeb5c
callq 0xee52
movq %rax, %r13
movq %r15, %rdi
callq 0x374c2
movq %r13, %rdi
movq %rax, %rsi
callq 0xea64
jmp 0xeb61
callq 0x4cfb8
movq %r15, %rdi
callq 0x37c10
movq %r12, %rdi
movq %r14, %rsi
callq 0x37d1e
movq %r15, %rdi
movq %r12, %rsi
callq 0x37dc8
testb %al, %al
je 0xeb21
jmp 0xebd7
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2748e
movq %r15, %rdi
callq 0x2450a
movb (%rbx), %al
movb (%r15), %cl
movb %cl, (%rbx)
movb %al, (%r15)
leaq 0x10(%rsp), %r14
movq 0x8(%rbx), %rax
movq (%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x2450a
movq %r15, %rdi
callq 0x2450a
movzbl -0x8(%r14), %esi
movq %r14, %rdi
callq 0x3c32c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq