LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: j-faria[P]kima/eigen/Eigen/src/Core/util/Memory.h
// Function: Eigen::internal::queryCacheSizes_intel_direct(int&, int&, int&)
inline void queryCacheSizes_intel_direct(int& l1, int& l2, int& l3)
{
  int abcd[4];
  l1 = l2 = l3 = 0;
  int cache_id = 0;
  int cache_type = 0;
  do {
    abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
    EIGEN_CPUID(abcd,0x4,cache_id);
    cache_type  = (abcd[0] & 0x0F) >> 0;
    if(cache_type==1||cache_type==3) // data or unified cache
    {
      int cache_level = (abcd[0] & 0xE0) >> 5;  // A[7:5]
      int ways        = (abcd[1] & 0xFFC00000) >> 22; // B[31:22]
      int partitions  = (abcd[1] & 0x003FF000) >> 12; // B[21:12]
      int line_size   = (abcd[1] & 0x00000FFF) >>  0; // B[11:0]
      int sets        = (abcd[2]);                    // C[31:0]

      int cache_size = (ways+1) * (partitions+1) * (line_size+1) * (sets+1);

      switch(cache_level)
      {
        case 1: l1 = cache_size; break;
        case 2: l2 = cache_size; break;
        case 3: l3 = cache_size; break;
        default: break;
      }
    }
    cache_id++;
  } while(cache_type>0 && cache_id<16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x34(%rbp), %ecx
movl $0x4, %eax
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl %esi, -0x54(%rbp)
movl %eax, %esi
movl -0x54(%rbp), %eax
movl %esi, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movl %ecx, -0x28(%rbp)
movl %edx, -0x24(%rbp)
movl -0x30(%rbp), %eax
andl $0xf, %eax
sarl $0x0, %eax
movl %eax, -0x38(%rbp)
cmpl $0x1, -0x38(%rbp)
je 0x42018
cmpl $0x3, -0x38(%rbp)
jne 0x420b0
movzbl -0x30(%rbp), %eax
shrl $0x5, %eax
movl %eax, -0x3c(%rbp)
movl -0x2c(%rbp), %eax
shrl $0x16, %eax
movl %eax, -0x40(%rbp)
movl -0x2c(%rbp), %eax
andl $0x3ff000, %eax         # imm = 0x3FF000
shrl $0xc, %eax
movl %eax, -0x44(%rbp)
movl -0x2c(%rbp), %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, -0x48(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x40(%rbp), %eax
incl %eax
movl -0x44(%rbp), %ecx
incl %ecx
imull %ecx, %eax
movl -0x48(%rbp), %ecx
incl %ecx
imull %ecx, %eax
movl -0x4c(%rbp), %ecx
incl %ecx
imull %ecx, %eax
movl %eax, -0x50(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x58(%rbp)
subl $0x1, %eax
je 0x4208b
jmp 0x42077
movl -0x58(%rbp), %eax
subl $0x2, %eax
je 0x42096
jmp 0x42081
movl -0x58(%rbp), %eax
subl $0x3, %eax
je 0x420a1
jmp 0x420ac
movl -0x50(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x420ae
movl -0x50(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x420ae
movl -0x50(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x420ae
jmp 0x420ae
jmp 0x420b0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x38(%rbp)
movb %al, -0x59(%rbp)
jle 0x420ce
cmpl $0x10, -0x34(%rbp)
setl %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x41fbc
popq %rbp
retq
nopl (%rax,%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/arch/SSE/PacketMath.h
// Function: void Eigen::internal::pbroadcast4<double vector[2]>(Eigen::internal::unpacket_traits<double vector[2]>::type const*, double vector[2]&, double vector[2]&, double vector[2]&, double vector[2]&)
EIGEN_STRONG_INLINE void
pbroadcast4<Packet2d>(const double *a,
                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
{
#ifdef EIGEN_VECTORIZE_SSE3
  a0 = _mm_loaddup_pd(a+0);
  a1 = _mm_loaddup_pd(a+1);
  a2 = _mm_loaddup_pd(a+2);
  a3 = _mm_loaddup_pd(a+3);
#else
  a1 = pload<Packet2d>(a);
  a0 = vec2d_swizzle1(a1, 0,0);
  a1 = vec2d_swizzle1(a1, 1,1);
  a3 = pload<Packet2d>(a+2);
  a2 = vec2d_swizzle1(a3, 0,0);
  a3 = vec2d_swizzle1(a3, 1,1);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdx, -0x98(%rbp)
movq %rcx, -0xa0(%rbp)
movq %r8, -0xa8(%rbp)
movq -0x88(%rbp), %rdi
callq 0x30710
movq -0x98(%rbp), %rax
movapd %xmm0, (%rax)
movq -0x98(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x10(%rbp)
movapd -0x10(%rbp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd %xmm0, -0x50(%rbp)
movaps -0x50(%rbp), %xmm0
movq -0x90(%rbp), %rax
movaps %xmm0, (%rax)
movq -0x98(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x20(%rbp)
movapd -0x20(%rbp), %xmm0
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movapd %xmm0, -0x60(%rbp)
movaps -0x60(%rbp), %xmm0
movq -0x98(%rbp), %rax
movaps %xmm0, (%rax)
movq -0x88(%rbp), %rdi
addq $0x10, %rdi
callq 0x30710
movq -0xa8(%rbp), %rax
movapd %xmm0, (%rax)
movq -0xa8(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x30(%rbp)
movapd -0x30(%rbp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd %xmm0, -0x70(%rbp)
movaps -0x70(%rbp), %xmm0
movq -0xa0(%rbp), %rax
movaps %xmm0, (%rax)
movq -0xa8(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x40(%rbp)
movapd -0x40(%rbp), %xmm0
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movdqa %xmm0, -0x80(%rbp)
movdqa -0x80(%rbp), %xmm0
movq -0xa8(%rbp), %rax
movapd %xmm0, (%rax)
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::lhs_process_one_packet<4, 2l, 1l, double, double, double, double vector[2], double vector[2], double vector[2], double vector[2], Eigen::internal::gebp_traits<double, double, false, false, 1, 0>, Eigen::internal::BlasLinearMapper<double, long, 0, 1>, Eigen::internal::blas_data_mapper<double, long, 0, 0, 1>>::peeled_kc_onestep(long, double const*, double const*, Eigen::internal::gebp_traits<double, double, false, false, 1, 0>, double vector[2]*, Eigen::internal::QuadPacket<double vector[2]>*, double vector[2]*, double vector[2]*, double vector[2]*, double vector[2]*, double vector[2]*)
EIGEN_STRONG_INLINE void peeled_kc_onestep(Index K, const LhsScalar* blA, const RhsScalar* blB, GEBPTraits traits, LhsPacket *A0, RhsPacketx4 *rhs_panel, RhsPacket *T0, AccPacket *C0, AccPacket *C1, AccPacket *C2, AccPacket *C3)
  {
    EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1X4");
    EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!");
    traits.loadLhs(&blA[(0+1*K)*LhsProgress], *A0);
    traits.loadRhs(&blB[(0+4*K)*RhsProgress], *rhs_panel);
    traits.madd(*A0, *rhs_panel, *C0, *T0, fix<0>);
    traits.madd(*A0, *rhs_panel, *C1, *T0, fix<1>);
    traits.madd(*A0, *rhs_panel, *C2, *T0, fix<2>);
    traits.madd(*A0, *rhs_panel, *C3, *T0, fix<3>);
    #if EIGEN_GNUC_AT_LEAST(6,0) && defined(EIGEN_VECTORIZE_SSE)
    __asm__  ("" : "+x,m" (*A0));
    #endif
    EIGEN_ASM_COMMENT("end step of gebp micro kernel 1X4");
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
shlq $0x0, %rax
addq $0x0, %rax
shlq %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x30(%rbp), %rdx
leaq -0x1(%rbp), %rdi
callq 0x46890
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
shlq $0x2, %rax
addq $0x0, %rax
shlq $0x0, %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x38(%rbp), %rdx
leaq -0x1(%rbp), %rdi
callq 0x468c0
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x18(%rbp), %rcx
movq 0x10(%rbp), %r8
leaq -0x1(%rbp), %rdi
leaq 0xd222a(%rip), %r9      # 0x11a788
callq 0x46900
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq 0x10(%rbp), %r8
leaq -0x1(%rbp), %rdi
leaq 0xd21fe(%rip), %r9      # 0x11a77c
callq 0x46960
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x28(%rbp), %rcx
movq 0x10(%rbp), %r8
leaq -0x1(%rbp), %rdi
leaq 0xd21eb(%rip), %r9      # 0x11a789
callq 0x469c0
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
leaq -0x1(%rbp), %rdi
leaq 0xd21cc(%rip), %r9      # 0x11a78a
callq 0x46a20
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/TriangularMatrix.h
// Function: void Eigen::internal::call_triangular_assignment_loop<1, true, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u> const&, Eigen::internal::assign_op<double, double> const&)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
  typedef evaluator<DstXprType> DstEvaluatorType;
  typedef evaluator<SrcXprType> SrcEvaluatorType;

  SrcEvaluatorType srcEvaluator(src);

  Index dstRows = src.rows();
  Index dstCols = src.cols();
  if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
    dst.resize(dstRows, dstCols);
  DstEvaluatorType dstEvaluator(dst);
    
  typedef triangular_dense_assignment_kernel< Mode&(Lower|Upper),Mode&(UnitDiag|ZeroDiag|SelfAdjoint),SetOpposite,
                                              DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
  
  enum {
      unroll = DstXprType::SizeAtCompileTime != Dynamic
            && SrcEvaluatorType::CoeffReadCost < HugeCost
            && DstXprType::SizeAtCompileTime * (DstEvaluatorType::CoeffReadCost+SrcEvaluatorType::CoeffReadCost) / 2 <= EIGEN_UNROLLING_LIMIT
    };
  
  triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(kernel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4c020
movq -0x10(%rbp), %rdi
callq 0x4bd20
movq %rax, -0x80(%rbp)
jmp 0x4bf03
movq -0x80(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4bd40
movq %rax, -0x88(%rbp)
jmp 0x4bf1d
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f070
movq %rax, -0x90(%rbp)
jmp 0x4bf3a
movq -0x90(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x4bf66
movq -0x8(%rbp), %rdi
callq 0x2f0b0
movq %rax, -0x98(%rbp)
jmp 0x4bf59
movq -0x98(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x4bf89
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x2fdc0
jmp 0x4bf79
jmp 0x4bf89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4c004
movq -0x8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x2f100
jmp 0x4bf98
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33f10
movq -0xa0(%rbp), %rcx
movq %rax, %r8
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x4c050
jmp 0x4bfc9
leaq -0x78(%rbp), %rdi
callq 0x4c090
jmp 0x4bfd4
leaq -0x58(%rbp), %rdi
callq 0x2f190
leaq -0x28(%rbp), %rdi
callq 0x4c1c0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2f190
leaq -0x28(%rbp), %rdi
callq 0x4c1c0
movq -0x38(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/TriangularMatrix.h
// Function: Eigen::internal::triangular_assignment_loop<Eigen::internal::triangular_dense_assignment_kernel<1, 0, 1, Eigen::internal::evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::evaluator<Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u>>, Eigen::internal::assign_op<double, double>, 0>, 1u, -1, true>::run(Eigen::internal::triangular_dense_assignment_kernel<1, 0, 1, Eigen::internal::evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::evaluator<Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u>>, Eigen::internal::assign_op<double, double>, 0>&)
EIGEN_DEVICE_FUNC
  static inline void run(Kernel &kernel)
  {
    for(Index j = 0; j < kernel.cols(); ++j)
    {
      Index maxi = numext::mini(j, kernel.rows());
      Index i = 0;
      if (((Mode&Lower) && SetOpposite) || (Mode&Upper))
      {
        for(; i < maxi; ++i)
          if(Mode&Upper) kernel.assignCoeff(i, j);
          else           kernel.assignOppositeCoeff(i, j);
      }
      else
        i = maxi;
      
      if(i<kernel.rows()) // then i==j
        kernel.assignDiagonalCoeff(i++);
      
      if (((Mode&Upper) && SetOpposite) || (Mode&Lower))
      {
        for(; i < kernel.rows(); ++i)
          if(Mode&Lower) kernel.assignCoeff(i, j);
          else           kernel.assignOppositeCoeff(i, j);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c280
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jge 0x4c1ad
movq -0x18(%rbp), %rdi
callq 0x4c2a0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7cf0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x4c127
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4c2c0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4c0fe
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c2a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jge 0x4c15c
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
callq 0x4c310
jmp 0x4c15e
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c2a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jge 0x4c19a
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4c340
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4c15e
jmp 0x4c19c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4c0a4
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/Solve.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Solve<Eigen::LLT<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::assign_op<double, double>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Solve<Eigen::LLT<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>> const&, Eigen::internal::assign_op<double, double> const&)
static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    Index dstRows = src.rows();
    Index dstCols = src.cols();
    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
      dst.resize(dstRows, dstCols);

    src.dec()._solve_impl(src.rhs(), dst);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4c810
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4c830
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f8d0
cmpq -0x20(%rbp), %rax
jne 0x4c8fc
movq -0x8(%rbp), %rdi
callq 0x2f8f0
cmpq -0x28(%rbp), %rax
je 0x4c90d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x30150
movq -0x10(%rbp), %rdi
callq 0x4c940
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4c990
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x8(%rbp), %rdx
callq 0x4c960
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/CwiseBinaryOp.h
// Function: Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const, 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>::CwiseBinaryOp(Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const&, 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&, Eigen::internal::scalar_product_op<double, double> const&)
CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp())
      : m_lhs(aLhs), m_rhs(aRhs), m_functor(func)
    {
      EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename Rhs::Scalar);
      // require the sizes to match
      EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
      eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols());
    }

// 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, -0x38(%rbp)
callq 0x50fa0
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x50fc0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x51010
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
movq -0x20(%rbp), %rsi
callq 0x51040
movq -0x10(%rbp), %rdi
callq 0x51050
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x50d90
movq -0x30(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
jne 0x50f38
movq -0x10(%rbp), %rdi
callq 0x51070
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x50db0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x50f41
jmp 0x50f43
jmp 0x50f62
leaq 0x6d18c(%rip), %rdi     # 0xbe0d6
leaq 0x74ce9(%rip), %rsi     # 0xc5c3a
movl $0x74, %edx
leaq 0x6d1b2(%rip), %rcx     # 0xbe10f
callq 0x6340
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: j-faria[P]kima/examples/trends/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "d1.txt";

    load(datafile, "ms", 2);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(100);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp            # imm = 0x6F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xad598(%rip), %rdi     # 0x11a7b8
movq %rdi, -0x6f0(%rbp)
leaq 0x58783(%rip), %rsi     # 0xc59b1
callq 0x6690
movq -0x6f0(%rbp), %rdi
movl $0x2, -0x14(%rbp)
leaq 0x4a2a1(%rip), %rsi     # 0xb74e9
leaq -0x14(%rbp), %rdx
callq 0x6d960
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x6d0(%rbp), %rdi
movq %rdi, -0x6e8(%rbp)
callq 0x6daa0
movq -0x6e8(%rbp), %rdi
movl $0x64, %esi
callq 0x6db40
jmp 0x6d27e
movl $0x0, -0x4(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6df60
movl -0x4(%rbp), %eax
addq $0x6f0, %rsp            # imm = 0x6F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6d8(%rbp)
movl %eax, -0x6dc(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6df60
movq -0x6d8(%rbp), %rdi
callq 0x6830
nopw (%rax,%rax)
// File: j-faria[P]kima/examples/trends/../../eigen/Eigen/src/Core/ProductEvaluators.h
// Function: Eigen::internal::product_evaluator<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1> const>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0>, 6, Eigen::DenseShape, Eigen::DenseShape, double, double>::product_evaluator(Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1> const>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0> const&)
explicit product_evaluator(const XprType& xpr)
    : m_result(xpr.rows(), xpr.cols())
  {
    ::new (static_cast<Base*>(this)) Base(m_result);
    
// FIXME shall we handle nested_eval here?,
// if so, then we must take care at removing the call to nested_eval in the specializations (e.g., in permutation_matrix_product, transposition_matrix_product, etc.)
//     typedef typename internal::nested_eval<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
//     typedef typename internal::nested_eval<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
//     typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
//     typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
//     
//     const LhsNested lhs(xpr.lhs());
//     const RhsNested rhs(xpr.rhs());
//   
//     generic_product_impl<LhsNestedCleaned, RhsNestedCleaned>::evalTo(m_result, lhs, rhs);

    generic_product_impl<Lhs, Rhs, LhsShape, RhsShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x83ff0
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x84010
movq %rax, -0x38(%rbp)
jmp 0x83f48
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x84030
movq %rax, -0x50(%rbp)
jmp 0x83f5f
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x84050
jmp 0x83f7a
movq -0x48(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x5a4c0
jmp 0x83f8c
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x84100
movq %rax, -0x58(%rbp)
jmp 0x83fa7
movq -0x10(%rbp), %rdi
callq 0x84110
movq %rax, -0x68(%rbp)
jmp 0x83fb6
movq -0x68(%rbp), %rdx
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x840a0
jmp 0x83fc9
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5a570
movq -0x20(%rbp), %rdi
callq 0x6830
nopl (%rax)
// File: j-faria[P]kima/examples/trends/../../eigen/Eigen/src/Core/AssignEvaluator.h
// Function: Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, 16, 16, 0, 16, 16>>, Eigen::internal::evaluator<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 16, 16, 0, 16, 16>>>, Eigen::internal::assign_op<double, double>, 0>, 2, 1>::run(Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, 16, 16, 0, 16, 16>>, Eigen::internal::evaluator<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 16, 16, 0, 16, 16>>>, Eigen::internal::assign_op<double, double>, 0>&)
void run(Kernel &kernel)
  {
    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
    typedef typename Kernel::AssignmentTraits Traits;
    const Index outerSize = kernel.outerSize();
    for(Index outer = 0; outer < outerSize; ++outer)
      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime,
                                                   Traits::SrcAlignment, Traits::DstAlignment>::run(kernel, outer);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9ccb0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x9ca76
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9ccd0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9ca51
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/examples/trends/../../DNest4/code/StartImpl.h
// Function: DNest4::Sampler<RVmodel> DNest4::setup<RVmodel>(DNest4::CommandLineOptions const&)
Sampler<ModelType> setup(const CommandLineOptions& options)
{
	std::cout<<"# Using "<<options.get_num_threads()<<" thread"<<
		((options.get_num_threads() == 1)?("."):("s."))<<std::endl;

	std::cout<<"# Target compression factor between levels = ";
	std::cout<<options.get_compression()<<std::endl;

	// Load sampler options from file
	Options sampler_options(options.get_options_file().c_str());

	// Create sampler
	Sampler<ModelType> sampler(options.get_num_threads(),
								options.get_compression_double(),
								sampler_options,
								true);

	// Seed RNGs
	sampler.initialise(options.get_seed_uint());

	return sampler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x7964d(%rip), %rdi     # 0x119f98
movq %rdi, -0xc8(%rbp)
leaq 0x2ab19(%rip), %rsi     # 0xcb472
callq 0x64f0
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa0b90
movq -0xd8(%rbp), %rdi
movl %eax, %esi
callq 0x6810
movq %rax, %rdi
leaq 0x2aaf5(%rip), %rsi     # 0xcb47b
callq 0x64f0
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa0b90
movq -0xd0(%rbp), %rdi
subl $0x1, %eax
leaq 0x2b60b(%rip), %rax     # 0xcbfb7
leaq 0x16c28(%rip), %rsi     # 0xb75db
cmoveq %rax, %rsi
callq 0x64f0
movq %rax, %rdi
movq 0x79552(%rip), %rsi     # 0x119f18
movq %rsi, -0xc0(%rbp)
callq 0x6530
movq -0xc8(%rbp), %rdi
leaq 0x2aaa3(%rip), %rsi     # 0xcb483
callq 0x64f0
movq -0x10(%rbp), %rdi
callq 0xa0bb0
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0x6490
movq -0xc0(%rbp), %rsi
movq %rax, %rdi
callq 0x6530
movq -0x10(%rbp), %rdi
callq 0xa0bd0
movq %rax, %rdi
callq 0x61e0
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
callq 0xb1d40
movb $0x0, -0xa1(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa0b90
movl %eax, -0xb8(%rbp)
jmp 0xa0a44
movq -0x10(%rbp), %rdi
callq 0xb11b0
movsd %xmm0, -0xf0(%rbp)
jmp 0xa0a57
movsd -0xf0(%rbp), %xmm0
movl -0xb8(%rbp), %esi
movq -0xe8(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
movl $0x1, %ecx
callq 0xa0be0
jmp 0xa0a7f
movq -0x10(%rbp), %rdi
callq 0xb1260
movl %eax, -0xf4(%rbp)
jmp 0xa0a90
movl -0xf4(%rbp), %esi
movq -0xe8(%rbp), %rdi
callq 0xa1360
jmp 0xa0aa4
movb $0x1, -0xa1(%rbp)
testb $0x1, -0xa1(%rbp)
jne 0xa0af6
jmp 0xa0aea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0xa0b12
movq -0xe8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
callq 0x6df60
jmp 0xa0b12
movq -0xe8(%rbp), %rdi
callq 0x6df60
leaq -0xa0(%rbp), %rdi
callq 0x6e4d0
movq -0xe0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0xa0(%rbp), %rdi
callq 0x6e4d0
movq -0xb0(%rbp), %rdi
callq 0x6830
nopw (%rax,%rax)
// File: j-faria[P]kima/examples/trends/../../DNest4/code/Utils.h
// Function: std::vector<unsigned long, std::allocator<unsigned long>> DNest4::argsort<DNest4::LikelihoodType>(std::vector<DNest4::LikelihoodType, std::allocator<DNest4::LikelihoodType>> const&)
std::vector<size_t> argsort(const std::vector<T>& v)
{
	// initialize original index locations
	std::vector<size_t> idx(v.size());
	for(size_t i=0; i<idx.size(); i++)
		idx[i] = i;

	// sort indexes based on comparing values in v
	std::sort(idx.begin(), idx.end(),
		[&v](size_t i1, size_t i2) {return v[i1] < v[i2];});

	return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa4e70
movq %rax, -0x58(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xa4e90
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xa4eb0
jmp 0xa1d5f
leaq -0x12(%rbp), %rdi
callq 0x32f70
movq $0x0, -0x30(%rbp)
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0xa4f20
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0xa1dce
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rsi
callq 0xa4f40
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xa1d70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x32f70
jmp 0xa1e3c
movq -0x60(%rbp), %rdi
callq 0xa4fb0
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0xa4fe0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xa4f60
jmp 0xa1e03
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa1e2f
jmp 0xa1e26
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xa2280
jmp 0xa1e3c
movq -0x60(%rbp), %rdi
callq 0xa2280
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
nop
// File: j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::initialise_output_files() const
void Sampler<ModelType>::initialise_output_files() const
{
	if(!save_to_disk)
		return;

	std::fstream fout;

	// Output headers
	fout.open(options.sample_info_file, std::ios::out);
	fout<<"# level assignment, log likelihood, tiebreaker, ID."<<std::endl;
	fout.close();

	fout.open(options.sample_file, std::ios::out);
	fout<<"# "<<particles[0].description().c_str()<<std::endl;
	fout.close();

	save_levels();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
testb $0x1, (%rax)
jne 0xa8aa4
jmp 0xa8be6
leaq -0x218(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x65b0
movq -0x250(%rbp), %rsi
movq -0x258(%rbp), %rdi
addq $0x88, %rsi
movl $0x10, %edx
callq 0x66a0
jmp 0xa8ad8
leaq -0x208(%rbp), %rdi
leaq 0x22b1a(%rip), %rsi     # 0xcb600
callq 0x64f0
movq %rax, -0x260(%rbp)
jmp 0xa8af4
movq -0x260(%rbp), %rdi
movq 0x71416(%rip), %rsi     # 0x119f18
callq 0x6530
jmp 0xa8b09
leaq -0x218(%rbp), %rdi
callq 0x6060
jmp 0xa8b17
movq -0x250(%rbp), %rsi
addq $0x68, %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x66a0
jmp 0xa8b35
leaq -0x208(%rbp), %rdi
leaq 0x22af1(%rip), %rsi     # 0xcb634
callq 0x64f0
movq %rax, -0x268(%rbp)
jmp 0xa8b51
movq -0x250(%rbp), %rdi
addq $0xc8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa8f30
movq %rax, %rsi
leaq -0x248(%rbp), %rdi
callq 0x24ae0
jmp 0xa8b79
leaq -0x248(%rbp), %rdi
callq 0x61e0
movq -0x268(%rbp), %rdi
movq %rax, %rsi
callq 0x64f0
movq %rax, -0x270(%rbp)
jmp 0xa8b9d
movq -0x270(%rbp), %rdi
movq 0x7136d(%rip), %rsi     # 0x119f18
callq 0x6530
jmp 0xa8bb2
leaq -0x248(%rbp), %rdi
callq 0x6948
leaq -0x218(%rbp), %rdi
callq 0x6060
jmp 0xa8bcc
movq -0x250(%rbp), %rdi
callq 0xa8f50
jmp 0xa8bda
leaq -0x218(%rbp), %rdi
callq 0x60f0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0xa8c21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x6948
leaq -0x218(%rbp), %rdi
callq 0x60f0
movq -0x220(%rbp), %rdi
callq 0x6830
nopl (%rax)
// File: j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::mcmc_thread(unsigned int)
void Sampler<ModelType>::mcmc_thread(unsigned int thread)
{
	// Reference to the RNG for this thread
	RNG& rng = rngs[thread];

	// Reference to this thread's copy of levels
	std::vector<Level>& _levels = copies_of_levels[thread];

	// First particle belonging to this thread
	const int start_index = thread*options.num_particles;

	// Do some MCMC
	int which;
	for(unsigned int i=0; i<options.thread_steps; ++i)
	{
		which = start_index + rng.rand_int(options.num_particles);

		if(rng.rand() <= 0.5)
		{
			update_particle(thread, which);
			update_level_assignment(thread, which);
		}
		else
		{
			update_level_assignment(thread, which);
			update_particle(thread, which);
		}
		if(!enough_levels(_levels) &&
				_levels.back().get_log_likelihood() < log_likelihoods[which])
			above[thread].push_back(log_likelihoods[which]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x678, %rdi            # imm = 0x678
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xa8770
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x648, %rdi            # imm = 0x648
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xaa000
movq -0x38(%rbp), %rcx
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
imull 0x38(%rcx), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x44(%rcx), %eax
jae 0xaa3e7
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
movl 0x38(%rax), %esi
callq 0xb28c0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb26f0
movaps %xmm0, %xmm1
movsd 0xce8a(%rip), %xmm0     # 0xb7198
ucomisd %xmm1, %xmm0
jb 0xaa334
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xab460
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xab7e0
jmp 0xaa352
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xab7e0
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xab460
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xabb20
testb $0x1, %al
jne 0xaa3d7
movq -0x20(%rbp), %rdi
callq 0xabcd0
movq %rax, %rdi
callq 0xa9390
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0xe0, %rdi
movslq -0x28(%rbp), %rsi
callq 0xa2260
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xb1a20
testb $0x1, %al
jne 0xaa39e
jmp 0xaa3d7
movq -0x38(%rbp), %rdi
addq $0x6a0, %rdi            # imm = 0x6A0
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xabd10
movq -0x38(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0xe0, %rdi
movslq -0x28(%rbp), %rsi
callq 0xa2260
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xaa650
jmp 0xaa3d9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xaa2ca
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::log_push(unsigned int) const
double Sampler<ModelType>::log_push(unsigned int which_level) const
{
	// Reference to this thread's copy of levels
	assert(which_level < levels.size());
	if(enough_levels(levels))
		return 0.0;

	int i = which_level - (static_cast<int>(levels.size()) - 1);
	return static_cast<double>(i)/options.lambda;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
addq $0x630, %rdi            # imm = 0x630
callq 0xa41f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xacd68
jmp 0xacd87
leaq 0x1e91f(%rip), %rdi     # 0xcb68e
leaq 0x1e74c(%rip), %rsi     # 0xcb4c2
movl $0x1be, %edx            # imm = 0x1BE
leaq 0x1e928(%rip), %rcx     # 0xcb6aa
callq 0x6340
movq -0x28(%rbp), %rdi
movq %rdi, %rsi
addq $0x630, %rsi            # imm = 0x630
callq 0xabb20
testb $0x1, %al
jne 0xacda0
jmp 0xacdaa
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xacde1
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x630, %rdi            # imm = 0x630
callq 0xa41f0
movl -0x2c(%rbp), %ecx
movq %rax, %rdx
movq -0x28(%rbp), %rax
subl $0x1, %edx
subl %edx, %ecx
movl %ecx, -0x18(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
divsd 0x50(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/DNest4/code/Barrier.cpp
// Function: DNest4::Barrier::wait()
void Barrier::wait()
{
	unsigned int gen = generation;
	std::unique_lock<std::mutex> lock{the_mutex};
	if((--count) == 0)
	{
		generation++;
		count = threshold;
		cond.notify_all();
	}
	else
		cond.wait(lock, [this, gen] { return gen != generation; });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movl 0x60(%rsi), %eax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb0620
movq -0x48(%rbp), %rcx
movl 0x5c(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x5c(%rcx)
cmpl $0x0, %eax
jne 0xb04a3
movq -0x48(%rbp), %rdi
movl 0x60(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x60(%rdi)
movl 0x58(%rdi), %eax
movl %eax, 0x5c(%rdi)
addq $0x28, %rdi
callq 0x67c0
jmp 0xb04e3
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rdx
movl -0x28(%rbp), %ecx
leaq -0x20(%rbp), %rsi
callq 0xb0500
jmp 0xb04ca
jmp 0xb04e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb0660
jmp 0xb04f2
leaq -0x20(%rbp), %rdi
callq 0xb0660
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6830
nopl (%rax,%rax)
// File: j-faria[P]kima/DNest4/code/CommandLineOptions.cpp
// Function: DNest4::CommandLineOptions::print_help() const
void CommandLineOptions::print_help() const
{
	std::cout<<"DNest4 Command Line Options: "<<std::endl;
	std::cout<<"-h: display this message"<<std::endl;
	std::cout<<"-o <filename>: load DNest4 options from the specified file. Default=OPTIONS"<<std::endl;
	std::cout<<"-s <seed>: seed the random number generator with the specified value. If unspecified, the system time is used."<<std::endl;
	std::cout<<"-d <filename>: Load data from the specified file, if required."<<std::endl;
	std::cout<<"-c <value>: Specify a compression value (between levels) other than e."<<std::endl;
	std::cout<<"-t <num_threads>: run on the specified number of threads. Default=1."<<std::endl;
	std::cout<<"-f <filename>: a custom configuration file for adding problem specific options if required."<<std::endl;
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x68f05(%rip), %rdi     # 0x119f98
leaq 0x1a950(%rip), %rsi     # 0xcb9ea
callq 0x64f0
movq %rax, %rdi
movq 0x68e6f(%rip), %rsi     # 0x119f18
callq 0x6530
movq 0x68ee3(%rip), %rdi     # 0x119f98
leaq 0x1a94c(%rip), %rsi     # 0xcba08
callq 0x64f0
movq %rax, %rdi
movq 0x68e4d(%rip), %rsi     # 0x119f18
callq 0x6530
movq 0x68ec1(%rip), %rdi     # 0x119f98
leaq 0x1a943(%rip), %rsi     # 0xcba21
callq 0x64f0
movq %rax, %rdi
movq 0x68e2b(%rip), %rsi     # 0x119f18
callq 0x6530
movq 0x68e9f(%rip), %rdi     # 0x119f98
leaq 0x1a96d(%rip), %rsi     # 0xcba6d
callq 0x64f0
movq %rax, %rdi
movq 0x68e09(%rip), %rsi     # 0x119f18
callq 0x6530
movq 0x68e7d(%rip), %rdi     # 0x119f98
leaq 0x1a9ba(%rip), %rsi     # 0xcbadc
callq 0x64f0
movq %rax, %rdi
movq 0x68de7(%rip), %rsi     # 0x119f18
callq 0x6530
movq 0x68e5b(%rip), %rdi     # 0x119f98
leaq 0x1a9d7(%rip), %rsi     # 0xcbb1b
callq 0x64f0
movq %rax, %rdi
movq 0x68dc5(%rip), %rsi     # 0x119f18
callq 0x6530
movq 0x68e39(%rip), %rdi     # 0x119f98
leaq 0x1a9fc(%rip), %rsi     # 0xcbb62
callq 0x64f0
movq %rax, %rdi
movq 0x68da3(%rip), %rsi     # 0x119f18
callq 0x6530
movq 0x68e17(%rip), %rdi     # 0x119f98
leaq 0x1aa1f(%rip), %rsi     # 0xcbba7
callq 0x64f0
movq %rax, %rdi
movq 0x68d81(%rip), %rsi     # 0x119f18
callq 0x6530
xorl %edi, %edi
callq 0x65d0
nopw %cs:(%rax,%rax)
// File: j-faria[P]kima/DNest4/code/CommandLineOptions.cpp
// Function: DNest4::CommandLineOptions::get_seed_uint() const
unsigned int CommandLineOptions::get_seed_uint() const
{
	if(seed.compare("time") == 0)
		return static_cast<unsigned int>(time(0));

	unsigned int i;
	std::stringstream s(seed);
	s>>i;
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
addq $0x20, %rdi
leaq 0x1a6bb(%rip), %rsi     # 0xcb940
callq 0x6150
cmpl $0x0, %eax
jne 0xb12a0
xorl %eax, %eax
movl %eax, %edi
callq 0x64b0
movl %eax, -0x4(%rbp)
jmp 0xb1323
movq -0x1b8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x1c8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x156e0
movq -0x1c8(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x6760
movq -0x1c0(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x6070
jmp 0xb12ef
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x63d0
jmp 0xb1323
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x63d0
jmp 0xb132f
movl -0x4(%rbp), %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x6830
nopl (%rax,%rax)
// File: j-faria[P]kima/DNest4/code/Level.cpp
// Function: DNest4::Level::recalculate_log_X(std::vector<DNest4::Level, std::allocator<DNest4::Level>>&, double, unsigned int)
void Level::recalculate_log_X(vector<Level>& levels, double compression,
												unsigned int regularisation)
{
	assert(levels.size() > 0);

	levels[0].log_X = 0.0;
	for(size_t i=1; i<levels.size(); ++i)
		levels[i].log_X = levels[i-1].log_X + log((double)(levels[i-1].exceeds + (1./compression)*regularisation)/(double)(levels[i-1].visits + regularisation));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa41f0
cmpq $0x0, %rax
jbe 0xb1405
jmp 0xb1424
leaq 0x1a804(%rip), %rdi     # 0xcbc10
leaq 0x1a80f(%rip), %rsi     # 0xcbc22
movl $0x23, %edx
leaq 0x1a80d(%rip), %rcx     # 0xcbc2c
callq 0x6340
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaa4b0
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa41f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xb1562
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
decq %rsi
callq 0xaa4b0
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
decq %rsi
callq 0xaa4b0
movq 0x20(%rax), %xmm1
movaps 0x5b78(%rip), %xmm0     # 0xb7010
movaps %xmm0, -0x60(%rbp)
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x5b78(%rip), %xmm0     # 0xb7020
movaps %xmm0, -0x50(%rbp)
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm2
movsd 0x5b68(%rip), %xmm0     # 0xb7030
divsd %xmm2, %xmm0
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
decq %rsi
callq 0xaa4b0
movaps -0x60(%rbp), %xmm3
movaps -0x50(%rbp), %xmm2
movsd -0x40(%rbp), %xmm0
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x6430
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xaa4b0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb1441
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: j-faria[P]kima/DNest4/code/Level.cpp
// Function: DNest4::Level::read(std::istream&)
void Level::read(istream& in)
{
	log_likelihood.read(in);
	in>>log_X;
	in>>visits;
	in>>exceeds;
	in>>accepts;
	in>>tries;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb1af0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rsi
callq 0x6440
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x18, %rsi
callq 0x65a0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
callq 0x65a0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
callq 0x65a0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rsi
callq 0x65a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/DNest4/code/LikelihoodType.cpp
// Function: DNest4::LikelihoodType::LikelihoodType(double, double)
LikelihoodType::LikelihoodType(double value, double tiebreaker)
{
	assert(tiebreaker > 0. && tiebreaker < 1.);
    if(std::isinf(value) || std::isnan(value))
        value = -1E300;
    this->value = value;
    this->tiebreaker = tiebreaker;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jbe 0xb1954
movsd 0x56e7(%rip), %xmm0     # 0xb7030
ucomisd -0x18(%rbp), %xmm0
seta %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xb195d
jmp 0xb195f
jmp 0xb197e
leaq 0x1a322(%rip), %rdi     # 0xcbc88
leaq 0x1a33e(%rip), %rsi     # 0xcbcab
movl $0x13, %edx
leaq 0x1a345(%rip), %rcx     # 0xcbcbe
callq 0x6340
movsd -0x10(%rbp), %xmm0
callq 0x2b080
testb $0x1, %al
jne 0xb199c
movsd -0x10(%rbp), %xmm0
callq 0x2b060
testb $0x1, %al
jne 0xb199c
jmp 0xb19a9
movsd 0x584c(%rip), %xmm0     # 0xb71f0
movsd %xmm0, -0x10(%rbp)
movq -0x28(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: j-faria[P]kima/DNest4/code/LikelihoodType.cpp
// Function: DNest4::LikelihoodType::operator<(DNest4::LikelihoodType const&) const
bool LikelihoodType::operator < (const LikelihoodType& other) const
{
	if(value < other.value)
		return true;
	if((value == other.value) &&
		(tiebreaker < other.tiebreaker))
		return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb1a4c
movb $0x1, -0x1(%rbp)
jmp 0xb1a82
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
jne 0xb1a7e
jp 0xb1a7e
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb1a7e
movb $0x1, -0x1(%rbp)
jmp 0xb1a82
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/DNest4/code/Options.cpp
// Function: DNest4::Options::print(std::ostream&) const
void Options::print(std::ostream& out) const
{
	out<<num_particles<<' ';
	out<<new_level_interval<<' ';
	out<<save_interval<<' ';
	out<<thread_steps<<' ';
	out<<max_num_levels<<' ';
	out<<lambda<<' ';
	out<<beta<<' ';
	out<<max_num_saves<<' ';

	out<<sample_file<<' ';
	out<<sample_info_file<<' ';
	out<<levels_file<<' ';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl (%rax), %esi
callq 0x6650
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x6650
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x8(%rax), %esi
callq 0x6650
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0xc(%rax), %esi
callq 0x6650
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %esi
callq 0x6650
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x18(%rax), %xmm0
callq 0x68f0
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x20(%rax), %xmm0
callq 0x68f0
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x28(%rax), %esi
callq 0x6650
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rsi
callq 0x6490
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x50, %rsi
callq 0x6490
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x70, %rsi
callq 0x6490
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
addq $0x20, %rsp
popq %rbp
retq
nop