// File: Pyboon[P]sage/./Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: Eigen::internal::general_matrix_matrix_product<long, std::complex<double>, 1, true, std::complex<double>, 0, false, 0>::run(long, long, long, std::complex<double> const*, long, std::complex<double> const*, long, std::complex<double>*, long, std::complex<double>, Eigen::internal::level3_blocking<std::complex<double>, std::complex<double>>&, Eigen::internal::GemmParallelInfo<long>*)
static void run(Index rows, Index cols, Index depth,
  const LhsScalar* _lhs, Index lhsStride,
  const RhsScalar* _rhs, Index rhsStride,
  ResScalar* _res, Index resStride,
  ResScalar alpha,
  level3_blocking<LhsScalar,RhsScalar>& blocking,
  GemmParallelInfo<Index>* info = 0)
{
  typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
  typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;
  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor> ResMapper;
  LhsMapper lhs(_lhs,lhsStride);
  RhsMapper rhs(_rhs,rhsStride);
  ResMapper res(_res, resStride);

  Index kc = blocking.kc();                   // cache block size along the K direction
  Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
  Index nc = (std::min)(cols,blocking.nc());  // cache block size along the N direction

  gemm_pack_lhs<LhsScalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
  gemm_pack_rhs<RhsScalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
  gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp;

#ifdef EIGEN_HAS_OPENMP
  if(info)
  {
    // this is the parallel version!
    int tid = omp_get_thread_num();
    int threads = omp_get_num_threads();

    LhsScalar* blockA = blocking.blockA();
    eigen_internal_assert(blockA!=0);

    std::size_t sizeB = kc*nc;
    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, 0);

    // For each horizontal panel of the rhs, and corresponding vertical panel of the lhs...
    for(Index k=0; k<depth; k+=kc)
    {
      const Index actual_kc = (std::min)(k+kc,depth)-k; // => rows of B', and cols of the A'

      // In order to reduce the chance that a thread has to wait for the other,
      // let's start by packing B'.
      pack_rhs(blockB, rhs.getSubMapper(k,0), actual_kc, nc);

      // Pack A_k to A' in a parallel fashion:
      // each thread packs the sub block A_k,i to A'_i where i is the thread id.

      // However, before copying to A'_i, we have to make sure that no other thread is still using it,
      // i.e., we test that info[tid].users equals 0.
      // Then, we set info[tid].users to the number of threads to mark that all other threads are going to use it.
      while(info[tid].users!=0) {}
      info[tid].users += threads;

      pack_lhs(blockA+info[tid].lhs_start*actual_kc, lhs.getSubMapper(info[tid].lhs_start,k), actual_kc, info[tid].lhs_length);

      // Notify the other threads that the part A'_i is ready to go.
      info[tid].sync = k;

      // Computes C_i += A' * B' per A'_i
      for(int shift=0; shift<threads; ++shift)
      {
        int i = (tid+shift)%threads;

        // At this point we have to make sure that A'_i has been updated by the thread i,
        // we use testAndSetOrdered to mimic a volatile access.
        // However, no need to wait for the B' part which has been updated by the current thread!
        if (shift>0) {
          while(info[i].sync!=k) {
          }
        }

        gebp(res.getSubMapper(info[i].lhs_start, 0), blockA+info[i].lhs_start*actual_kc, blockB, info[i].lhs_length, actual_kc, nc, alpha);
      }

      // Then keep going as usual with the remaining B'
      for(Index j=nc; j<cols; j+=nc)
      {
        const Index actual_nc = (std::min)(j+nc,cols)-j;

        // pack B_k,j to B'
        pack_rhs(blockB, rhs.getSubMapper(k,j), actual_kc, actual_nc);

        // C_j += A' * B'
        gebp(res.getSubMapper(0, j), blockA, blockB, rows, actual_kc, actual_nc, alpha);
      }

      // Release all the sub blocks A'_i of A' for the current thread,
      // i.e., we simply decrement the number of users by 1
      for(Index i=0; i<threads; ++i)
        #pragma omp atomic
        info[i].users -= 1;
    }
  }
  else
#endif // EIGEN_HAS_OPENMP
  {
    EIGEN_UNUSED_VARIABLE(info);

    // this is the sequential version!
    std::size_t sizeA = kc*mc;
    std::size_t sizeB = kc*nc;

    ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, blocking.blockA());
    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, blocking.blockB());

    const bool pack_rhs_once = mc!=rows && kc==depth && nc==cols;

    // For each horizontal panel of the rhs, and corresponding panel of the lhs...
    for(Index i2=0; i2<rows; i2+=mc)
    {
      const Index actual_mc = (std::min)(i2+mc,rows)-i2;

      for(Index k2=0; k2<depth; k2+=kc)
      {
        const Index actual_kc = (std::min)(k2+kc,depth)-k2;

        // OK, here we have selected one horizontal panel of rhs and one vertical panel of lhs.
        // => Pack lhs's panel into a sequential chunk of memory (L2/L3 caching)
        // Note that this panel will be read as many times as the number of blocks in the rhs's
        // horizontal panel which is, in practice, a very low number.
        pack_lhs(blockA, lhs.getSubMapper(i2,k2), actual_kc, actual_mc);

        // For each kc x nc block of the rhs's horizontal panel...
        for(Index j2=0; j2<cols; j2+=nc)
        {
          const Index actual_nc = (std::min)(j2+nc,cols)-j2;

          // We pack the rhs's block into a sequential chunk of memory (L2 caching)
          // Note that this block will be read a very high number of times, which is equal to the number of
          // micro horizontal panel of the large rhs's panel (e.g., rows/12 times).
          if((!pack_rhs_once) || i2==0)
            pack_rhs(blockB, rhs.getSubMapper(k2,j2), actual_kc, actual_nc);

          // Everything is packed, we can now call the panel * block kernel:
          gebp(res.getSubMapper(i2, j2), blockA, blockB, actual_mc, actual_kc, actual_nc, alpha);
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movsd %xmm0, -0x1d0(%rbp)
movsd %xmm1, -0x1c8(%rbp)
movq %rdi, -0x1d8(%rbp)
movq %rsi, -0x1e0(%rbp)
movq %rdx, -0x1e8(%rbp)
movq %rcx, -0x1f0(%rbp)
movq %r8, -0x1f8(%rbp)
movq %r9, -0x200(%rbp)
movq -0x1f0(%rbp), %rcx
movq -0x1f8(%rbp), %rax
leaq -0x210(%rbp), %rdx
movq %rdx, -0x1a0(%rbp)
movq %rcx, -0x1a8(%rbp)
movq %rax, -0x1b0(%rbp)
movq -0x1a0(%rbp), %rdx
movq -0x1a8(%rbp), %rcx
movq -0x1b0(%rbp), %rax
movq %rdx, -0x170(%rbp)
movq %rcx, -0x178(%rbp)
movq %rax, -0x180(%rbp)
movq -0x170(%rbp), %rax
movq -0x178(%rbp), %rcx
movq %rcx, (%rax)
movq -0x180(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x200(%rbp), %rcx
movq 0x10(%rbp), %rax
leaq -0x220(%rbp), %rdx
movq %rdx, -0x188(%rbp)
movq %rcx, -0x190(%rbp)
movq %rax, -0x198(%rbp)
movq -0x188(%rbp), %rdx
movq -0x190(%rbp), %rcx
movq -0x198(%rbp), %rax
movq %rdx, -0x158(%rbp)
movq %rcx, -0x160(%rbp)
movq %rax, -0x168(%rbp)
movq -0x158(%rbp), %rax
movq -0x160(%rbp), %rcx
movq %rcx, (%rax)
movq -0x168(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rbp), %rcx
movq 0x20(%rbp), %rax
leaq -0x230(%rbp), %rdx
movq %rdx, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rax, -0x150(%rbp)
movq -0x140(%rbp), %rax
movq -0x148(%rbp), %rcx
movq %rcx, (%rax)
movq -0x150(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x28(%rbp), %rdi
callq 0x3f720
movq %rax, -0x238(%rbp)
movq 0x28(%rbp), %rdi
callq 0x3f740
movq %rax, -0x248(%rbp)
leaq -0x1d8(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
movq %rax, -0x240(%rbp)
movq 0x28(%rbp), %rdi
callq 0x3f760
movq %rax, -0x258(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
movq %rax, -0x250(%rbp)
leaq 0x30(%rbp), %rdi
callq 0x3f780
movq -0x238(%rbp), %rax
imulq -0x240(%rbp), %rax
movq %rax, -0x268(%rbp)
movq -0x238(%rbp), %rax
imulq -0x250(%rbp), %rax
movq %rax, -0x270(%rbp)
movq -0x268(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
cmpq %rax, -0x1b8(%rbp)
jbe 0x3ed5b
callq 0x14c90
movq 0x28(%rbp), %rdi
callq 0x3f790
cmpq $0x0, %rax
je 0x3ed7c
movq 0x28(%rbp), %rdi
callq 0x3f790
movq %rax, -0x358(%rbp)
jmp 0x3ede5
movq -0x268(%rbp), %rax
shlq $0x4, %rax
cmpq $0x20000, %rax          # imm = 0x20000
ja 0x3edc0
movq -0x268(%rbp), %rcx
shlq $0x4, %rcx
addq $0x1e, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
addq $0x10, %rax
subq $0x1, %rax
andq $-0x10, %rax
movq %rax, -0x360(%rbp)
jmp 0x3edd7
movq -0x268(%rbp), %rdi
shlq $0x4, %rdi
callq 0x14db0
movq %rax, -0x360(%rbp)
movq -0x360(%rbp), %rax
movq %rax, -0x358(%rbp)
movq -0x358(%rbp), %rax
movq %rax, -0x278(%rbp)
movq 0x28(%rbp), %rdi
callq 0x3f790
cmpq $0x0, %rax
jne 0x3ee12
movq -0x278(%rbp), %rax
movq %rax, -0x368(%rbp)
jmp 0x3ee1d
xorl %eax, %eax
movq %rax, -0x368(%rbp)
jmp 0x3ee1d
movq -0x368(%rbp), %rsi
movq -0x268(%rbp), %rdx
movq -0x268(%rbp), %rax
shlq $0x4, %rax
cmpq $0x20000, %rax          # imm = 0x20000
seta %al
movzbl %al, %ecx
andl $0x1, %ecx
leaq -0x290(%rbp), %rdi
callq 0x32410
movq -0x270(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
cmpq %rax, -0x1c0(%rbp)
jbe 0x3ee7b
callq 0x14c90
jmp 0x3ee79
jmp 0x3ee7b
jmp 0x3ee7d
movq 0x28(%rbp), %rdi
callq 0x3f7b0
movq %rax, -0x370(%rbp)
jmp 0x3ee8f
movq -0x370(%rbp), %rax
cmpq $0x0, %rax
je 0x3eebe
movq 0x28(%rbp), %rdi
callq 0x3f7b0
movq %rax, -0x378(%rbp)
jmp 0x3eeae
movq -0x378(%rbp), %rax
movq %rax, -0x380(%rbp)
jmp 0x3ef39
movq -0x270(%rbp), %rax
shlq $0x4, %rax
cmpq $0x20000, %rax          # imm = 0x20000
ja 0x3ef02
movq -0x270(%rbp), %rcx
shlq $0x4, %rcx
addq $0x1e, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
addq $0x10, %rax
subq $0x1, %rax
andq $-0x10, %rax
movq %rax, -0x388(%rbp)
jmp 0x3ef2b
movq -0x270(%rbp), %rdi
shlq $0x4, %rdi
callq 0x14db0
movq %rax, -0x390(%rbp)
jmp 0x3ef1b
movq -0x390(%rbp), %rax
movq %rax, -0x388(%rbp)
jmp 0x3ef2b
movq -0x388(%rbp), %rax
movq %rax, -0x380(%rbp)
movq -0x380(%rbp), %rax
movq %rax, -0x2a8(%rbp)
movq 0x28(%rbp), %rdi
callq 0x3f7b0
movq %rax, -0x398(%rbp)
jmp 0x3ef59
movq -0x398(%rbp), %rax
cmpq $0x0, %rax
jne 0x3ef76
movq -0x2a8(%rbp), %rax
movq %rax, -0x3a0(%rbp)
jmp 0x3ef81
xorl %eax, %eax
movq %rax, -0x3a0(%rbp)
jmp 0x3ef81
movq -0x3a0(%rbp), %rsi
movq -0x270(%rbp), %rdx
movq %rdx, %rax
shlq $0x4, %rax
subq $0x20001, %rax          # imm = 0x20001
setae %al
movzbl %al, %ecx
leaq -0x2c0(%rbp), %rdi
callq 0x32410
jmp 0x3efb0
movq -0x240(%rbp), %rcx
xorl %eax, %eax
cmpq -0x1d8(%rbp), %rcx
movb %al, -0x3a1(%rbp)
je 0x3eff7
movq -0x238(%rbp), %rcx
xorl %eax, %eax
cmpq -0x1e8(%rbp), %rcx
movb %al, -0x3a1(%rbp)
jne 0x3eff7
movq -0x250(%rbp), %rax
cmpq -0x1e0(%rbp), %rax
sete %al
movb %al, -0x3a1(%rbp)
movb -0x3a1(%rbp), %al
andb $0x1, %al
movb %al, -0x2c1(%rbp)
movq $0x0, -0x2d0(%rbp)
movq -0x2d0(%rbp), %rax
cmpq -0x1d8(%rbp), %rax
jge 0x3f5a9
movq -0x2d0(%rbp), %rax
addq -0x240(%rbp), %rax
movq %rax, -0x2e0(%rbp)
leaq -0x2e0(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
subq -0x2d0(%rbp), %rax
movq %rax, -0x2d8(%rbp)
movq $0x0, -0x2e8(%rbp)
movq -0x2e8(%rbp), %rax
cmpq -0x1e8(%rbp), %rax
jge 0x3f58d
movq -0x2e8(%rbp), %rax
movq -0x238(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x2f8(%rbp)
leaq -0x2f8(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
movq -0x2e8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x2f0(%rbp)
movq -0x278(%rbp), %rax
movq %rax, -0x3c0(%rbp)
movq -0x2d0(%rbp), %rcx
movq -0x2e8(%rbp), %rax
leaq -0x210(%rbp), %rdx
movq %rdx, -0x128(%rbp)
movq %rcx, -0x130(%rbp)
movq %rax, -0x138(%rbp)
movq -0x128(%rbp), %rax
movq -0x130(%rbp), %rdx
movq -0x138(%rbp), %rcx
movq %rax, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq -0xe8(%rbp), %rdi
movq -0xf8(%rbp), %rdx
movq -0xf0(%rbp), %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
imulq %rdi, %rsi
addq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rax), %rax
leaq -0x120(%rbp), %rdx
movq %rdx, -0x100(%rbp)
movq %rcx, -0x108(%rbp)
movq %rax, -0x110(%rbp)
movq -0x100(%rbp), %rdx
movq -0x108(%rbp), %rcx
movq -0x110(%rbp), %rax
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rax, -0xe0(%rbp)
movq -0xd0(%rbp), %rax
movq -0xd8(%rbp), %rcx
movq %rcx, (%rax)
movq -0xe0(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x120(%rbp), %rax
movq %rax, -0x3b8(%rbp)
movq -0x118(%rbp), %rax
movq %rax, -0x3b0(%rbp)
movq -0x3c0(%rbp), %rsi
movq -0x3b0(%rbp), %rax
movq -0x3b8(%rbp), %rcx
movq %rcx, -0x308(%rbp)
movq %rax, -0x300(%rbp)
movq -0x2f0(%rbp), %rcx
movq -0x2d8(%rbp), %r8
subq $0x10, %rsp
movq %rsp, %rax
movq $0x0, (%rax)
xorl %eax, %eax
movl %eax, %r9d
leaq -0x259(%rbp), %rdi
leaq -0x308(%rbp), %rdx
callq 0x3f7d0
addq $0x10, %rsp
jmp 0x3f226
movq $0x0, -0x310(%rbp)
movq -0x310(%rbp), %rax
cmpq -0x1e0(%rbp), %rax
jge 0x3f571
movq -0x310(%rbp), %rax
addq -0x250(%rbp), %rax
movq %rax, -0x320(%rbp)
leaq -0x320(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x3e940
movq (%rax), %rax
subq -0x310(%rbp), %rax
movq %rax, -0x318(%rbp)
testb $0x1, -0x2c1(%rbp)
je 0x3f295
cmpq $0x0, -0x2d0(%rbp)
jne 0x3f41e
movq -0x2a8(%rbp), %rax
movq %rax, -0x3d8(%rbp)
movq -0x2e8(%rbp), %rcx
movq -0x310(%rbp), %rax
leaq -0x220(%rbp), %rdx
movq %rdx, -0xb8(%rbp)
movq %rcx, -0xc0(%rbp)
movq %rax, -0xc8(%rbp)
movq -0xb8(%rbp), %rax
movq -0xc0(%rbp), %rdx
movq -0xc8(%rbp), %rcx
movq %rax, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movq %rcx, -0x88(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
imulq %rdi, %rsi
addq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rax), %rax
leaq -0xb0(%rbp), %rdx
movq %rdx, -0x90(%rbp)
movq %rcx, -0x98(%rbp)
movq %rax, -0xa0(%rbp)
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq %rdx, -0x60(%rbp)
movq %rcx, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0xb0(%rbp), %rax
movq %rax, -0x3d0(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x3c8(%rbp)
movq -0x3d8(%rbp), %rsi
movq -0x3c8(%rbp), %rax
movq -0x3d0(%rbp), %rcx
movq %rcx, -0x330(%rbp)
movq %rax, -0x328(%rbp)
movq -0x2f0(%rbp), %rcx
movq -0x318(%rbp), %r8
subq $0x10, %rsp
movq %rsp, %rax
movq $0x0, (%rax)
xorl %eax, %eax
movl %eax, %r9d
leaq -0x25a(%rbp), %rdi
leaq -0x330(%rbp), %rdx
callq 0x400c0
addq $0x10, %rsp
jmp 0x3f3e2
jmp 0x3f41e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x298(%rbp)
movl %eax, -0x29c(%rbp)
jmp 0x3f5c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x298(%rbp)
movl %eax, -0x29c(%rbp)
leaq -0x2c0(%rbp), %rdi
callq 0x35810
jmp 0x3f5c6
movq -0x2d0(%rbp), %rcx
movq -0x310(%rbp), %rax
leaq -0x230(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq %rax, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
imulq %rdi, %rsi
addq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rax), %rax
leaq -0x40(%rbp), %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x3e8(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x3e0(%rbp)
movq -0x3e0(%rbp), %rax
movq -0x3e8(%rbp), %rcx
movq %rcx, -0x340(%rbp)
movq %rax, -0x338(%rbp)
movq -0x278(%rbp), %rdx
movq -0x2a8(%rbp), %rcx
movq -0x2d8(%rbp), %r8
movq -0x2f0(%rbp), %r9
movq -0x318(%rbp), %rsi
movups -0x1d0(%rbp), %xmm0
movaps %xmm0, -0x350(%rbp)
movsd -0x350(%rbp), %xmm0
movsd -0x348(%rbp), %xmm1
subq $0x30, %rsp
movq %rsp, %rax
movq %rsi, (%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
movq $-0x1, 0x10(%rax)
movq $-0x1, 0x8(%rax)
leaq -0x25b(%rbp), %rdi
leaq -0x340(%rbp), %rsi
callq 0x407e0
addq $0x30, %rsp
jmp 0x3f555
jmp 0x3f557
movq -0x250(%rbp), %rax
addq -0x310(%rbp), %rax
movq %rax, -0x310(%rbp)
jmp 0x3f231
jmp 0x3f573
movq -0x238(%rbp), %rax
addq -0x2e8(%rbp), %rax
movq %rax, -0x2e8(%rbp)
jmp 0x3f068
jmp 0x3f58f
movq -0x240(%rbp), %rax
addq -0x2d0(%rbp), %rax
movq %rax, -0x2d0(%rbp)
jmp 0x3f010
leaq -0x2c0(%rbp), %rdi
callq 0x35810
leaq -0x290(%rbp), %rdi
callq 0x35810
movq %rbp, %rsp
popq %rbp
retq
leaq -0x290(%rbp), %rdi
callq 0x35810
movq -0x298(%rbp), %rdi
callq 0x9dc0
nop