// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/./Eigen/src/Core/products/GeneralMatrixVector.h
// Function: Eigen::internal::general_matrix_vector_product<long, double, Eigen::internal::const_blas_data_mapper<double, long, 0>, 0, false, double, Eigen::internal::const_blas_data_mapper<double, long, 1>, false, 0>::run(long, long, Eigen::internal::const_blas_data_mapper<double, long, 0> const&, Eigen::internal::const_blas_data_mapper<double, long, 1> const&, double*, long, double)
EIGEN_DONT_INLINE void general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>::run(
  Index rows, Index cols,
  const LhsMapper& lhs,
  const RhsMapper& rhs,
        ResScalar* res, Index resIncr,
  RhsScalar alpha)
{
  EIGEN_UNUSED_VARIABLE(resIncr);
  eigen_internal_assert(resIncr==1);
  #ifdef _EIGEN_ACCUMULATE_PACKETS
  #error _EIGEN_ACCUMULATE_PACKETS has already been defined
  #endif
  #define _EIGEN_ACCUMULATE_PACKETS(Alignment0,Alignment13,Alignment2) \
    pstore(&res[j], \
      padd(pload<ResPacket>(&res[j]), \
        padd( \
      padd(pcj.pmul(lhs0.template load<LhsPacket, Alignment0>(j),    ptmp0), \
      pcj.pmul(lhs1.template load<LhsPacket, Alignment13>(j),   ptmp1)),   \
      padd(pcj.pmul(lhs2.template load<LhsPacket, Alignment2>(j),    ptmp2), \
      pcj.pmul(lhs3.template load<LhsPacket, Alignment13>(j),   ptmp3)) )))

  typedef typename LhsMapper::VectorMapper LhsScalars;

  conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
  conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj;
  if(ConjugateRhs)
    alpha = numext::conj(alpha);

  enum { AllAligned = 0, EvenAligned, FirstAligned, NoneAligned };
  const Index columnsAtOnce = 4;
  const Index peels = 2;
  const Index LhsPacketAlignedMask = LhsPacketSize-1;
  const Index ResPacketAlignedMask = ResPacketSize-1;
//  const Index PeelAlignedMask = ResPacketSize*peels-1;
  const Index size = rows;

  const Index lhsStride = lhs.stride();

  // How many coeffs of the result do we have to skip to be aligned.
  // Here we assume data are at least aligned on the base scalar type.
  Index alignedStart = internal::first_default_aligned(res,size);
  Index alignedSize = ResPacketSize>1 ? alignedStart + ((size-alignedStart) & ~ResPacketAlignedMask) : 0;
  const Index peeledSize = alignedSize - RhsPacketSize*peels - RhsPacketSize + 1;

  const Index alignmentStep = LhsPacketSize>1 ? (LhsPacketSize - lhsStride % LhsPacketSize) & LhsPacketAlignedMask : 0;
  Index alignmentPattern = alignmentStep==0 ? AllAligned
                       : alignmentStep==(LhsPacketSize/2) ? EvenAligned
                       : FirstAligned;

  // we cannot assume the first element is aligned because of sub-matrices
  const Index lhsAlignmentOffset = lhs.firstAligned(size);

  // find how many columns do we have to skip to be aligned with the result (if possible)
  Index skipColumns = 0;
  // if the data cannot be aligned (TODO add some compile time tests when possible, e.g. for floats)
  if( (lhsAlignmentOffset < 0) || (lhsAlignmentOffset == size) || (UIntPtr(res)%sizeof(ResScalar)) )
  {
    alignedSize = 0;
    alignedStart = 0;
    alignmentPattern = NoneAligned;
  }
  else if(LhsPacketSize > 4)
  {
    // TODO: extend the code to support aligned loads whenever possible when LhsPacketSize > 4.
    // Currently, it seems to be better to perform unaligned loads anyway
    alignmentPattern = NoneAligned;
  }
  else if (LhsPacketSize>1)
  {
  //    eigen_internal_assert(size_t(firstLhs+lhsAlignmentOffset)%sizeof(LhsPacket)==0 || size<LhsPacketSize);

    while (skipColumns<LhsPacketSize &&
          alignedStart != ((lhsAlignmentOffset + alignmentStep*skipColumns)%LhsPacketSize))
      ++skipColumns;
    if (skipColumns==LhsPacketSize)
    {
      // nothing can be aligned, no need to skip any column
      alignmentPattern = NoneAligned;
      skipColumns = 0;
    }
    else
    {
      skipColumns = (std::min)(skipColumns,cols);
      // note that the skiped columns are processed later.
    }

    /*    eigen_internal_assert(  (alignmentPattern==NoneAligned)
                      || (skipColumns + columnsAtOnce >= cols)
                      || LhsPacketSize > size
                      || (size_t(firstLhs+alignedStart+lhsStride*skipColumns)%sizeof(LhsPacket))==0);*/
  }
  else if(Vectorizable)
  {
    alignedStart = 0;
    alignedSize = size;
    alignmentPattern = AllAligned;
  }

  const Index offset1 = (alignmentPattern==FirstAligned && alignmentStep==1)?3:1;
  const Index offset3 = (alignmentPattern==FirstAligned && alignmentStep==1)?1:3;

  Index columnBound = ((cols-skipColumns)/columnsAtOnce)*columnsAtOnce + skipColumns;
  for (Index i=skipColumns; i<columnBound; i+=columnsAtOnce)
  {
    RhsPacket ptmp0 = pset1<RhsPacket>(alpha*rhs(i, 0)),
              ptmp1 = pset1<RhsPacket>(alpha*rhs(i+offset1, 0)),
              ptmp2 = pset1<RhsPacket>(alpha*rhs(i+2, 0)),
              ptmp3 = pset1<RhsPacket>(alpha*rhs(i+offset3, 0));

    // this helps a lot generating better binary code
    const LhsScalars lhs0 = lhs.getVectorMapper(0, i+0),   lhs1 = lhs.getVectorMapper(0, i+offset1),
                     lhs2 = lhs.getVectorMapper(0, i+2),   lhs3 = lhs.getVectorMapper(0, i+offset3);

    if (Vectorizable)
    {
      /* explicit vectorization */
      // process initial unaligned coeffs
      for (Index j=0; j<alignedStart; ++j)
      {
        res[j] = cj.pmadd(lhs0(j), pfirst(ptmp0), res[j]);
        res[j] = cj.pmadd(lhs1(j), pfirst(ptmp1), res[j]);
        res[j] = cj.pmadd(lhs2(j), pfirst(ptmp2), res[j]);
        res[j] = cj.pmadd(lhs3(j), pfirst(ptmp3), res[j]);
      }

      if (alignedSize>alignedStart)
      {
        switch(alignmentPattern)
        {
          case AllAligned:
            for (Index j = alignedStart; j<alignedSize; j+=ResPacketSize)
              _EIGEN_ACCUMULATE_PACKETS(Aligned,Aligned,Aligned);
            break;
          case EvenAligned:
            for (Index j = alignedStart; j<alignedSize; j+=ResPacketSize)
              _EIGEN_ACCUMULATE_PACKETS(Aligned,Unaligned,Aligned);
            break;
          case FirstAligned:
          {
            Index j = alignedStart;
            if(peels>1)
            {
              LhsPacket A00, A01, A02, A03, A10, A11, A12, A13;
              ResPacket T0, T1;

              A01 = lhs1.template load<LhsPacket, Aligned>(alignedStart-1);
              A02 = lhs2.template load<LhsPacket, Aligned>(alignedStart-2);
              A03 = lhs3.template load<LhsPacket, Aligned>(alignedStart-3);

              for (; j<peeledSize; j+=peels*ResPacketSize)
              {
                A11 = lhs1.template load<LhsPacket, Aligned>(j-1+LhsPacketSize);  palign<1>(A01,A11);
                A12 = lhs2.template load<LhsPacket, Aligned>(j-2+LhsPacketSize);  palign<2>(A02,A12);
                A13 = lhs3.template load<LhsPacket, Aligned>(j-3+LhsPacketSize);  palign<3>(A03,A13);

                A00 = lhs0.template load<LhsPacket, Aligned>(j);
                A10 = lhs0.template load<LhsPacket, Aligned>(j+LhsPacketSize);
                T0  = pcj.pmadd(A00, ptmp0, pload<ResPacket>(&res[j]));
                T1  = pcj.pmadd(A10, ptmp0, pload<ResPacket>(&res[j+ResPacketSize]));

                T0  = pcj.pmadd(A01, ptmp1, T0);
                A01 = lhs1.template load<LhsPacket, Aligned>(j-1+2*LhsPacketSize);  palign<1>(A11,A01);
                T0  = pcj.pmadd(A02, ptmp2, T0);
                A02 = lhs2.template load<LhsPacket, Aligned>(j-2+2*LhsPacketSize);  palign<2>(A12,A02);
                T0  = pcj.pmadd(A03, ptmp3, T0);
                pstore(&res[j],T0);
                A03 = lhs3.template load<LhsPacket, Aligned>(j-3+2*LhsPacketSize);  palign<3>(A13,A03);
                T1  = pcj.pmadd(A11, ptmp1, T1);
                T1  = pcj.pmadd(A12, ptmp2, T1);
                T1  = pcj.pmadd(A13, ptmp3, T1);
                pstore(&res[j+ResPacketSize],T1);
              }
            }
            for (; j<alignedSize; j+=ResPacketSize)
              _EIGEN_ACCUMULATE_PACKETS(Aligned,Unaligned,Unaligned);
            break;
          }
          default:
            for (Index j = alignedStart; j<alignedSize; j+=ResPacketSize)
              _EIGEN_ACCUMULATE_PACKETS(Unaligned,Unaligned,Unaligned);
            break;
        }
      }
    } // end explicit vectorization

    /* process remaining coeffs (or all if there is no explicit vectorization) */
    for (Index j=alignedSize; j<size; ++j)
    {
      res[j] = cj.pmadd(lhs0(j), pfirst(ptmp0), res[j]);
      res[j] = cj.pmadd(lhs1(j), pfirst(ptmp1), res[j]);
      res[j] = cj.pmadd(lhs2(j), pfirst(ptmp2), res[j]);
      res[j] = cj.pmadd(lhs3(j), pfirst(ptmp3), res[j]);
    }
  }

  // process remaining first and last columns (at most columnsAtOnce-1)
  Index end = cols;
  Index start = columnBound;
  do
  {
    for (Index k=start; k<end; ++k)
    {
      RhsPacket ptmp0 = pset1<RhsPacket>(alpha*rhs(k, 0));
      const LhsScalars lhs0 = lhs.getVectorMapper(0, k);

      if (Vectorizable)
      {
        /* explicit vectorization */
        // process first unaligned result's coeffs
        for (Index j=0; j<alignedStart; ++j)
          res[j] += cj.pmul(lhs0(j), pfirst(ptmp0));
        // process aligned result's coeffs
        if (lhs0.template aligned<LhsPacket>(alignedStart))
          for (Index i = alignedStart;i<alignedSize;i+=ResPacketSize)
            pstore(&res[i], pcj.pmadd(lhs0.template load<LhsPacket, Aligned>(i), ptmp0, pload<ResPacket>(&res[i])));
        else
          for (Index i = alignedStart;i<alignedSize;i+=ResPacketSize)
            pstore(&res[i], pcj.pmadd(lhs0.template load<LhsPacket, Unaligned>(i), ptmp0, pload<ResPacket>(&res[i])));
      }

      // process remaining scalars (or all if no explicit vectorization)
      for (Index i=alignedSize; i<size; ++i)
        res[i] += cj.pmul(lhs0(i), pfirst(ptmp0));
    }
    if (skipColumns)
    {
      start = 0;
      end = skipColumns;
      skipColumns = 0;
    }
    else
      break;
  } while(Vectorizable);
  #undef _EIGEN_ACCUMULATE_PACKETS
}

// Assembly:
movq %rdi, %r11
testb $0x7, %r8b
jne 0x2655f
movl %r8d, %r11d
shrl $0x3, %r11d
andl $0x1, %r11d
cmpq %rdi, %r11
cmovgeq %rdi, %r11
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
subq %r11, %rbx
andq $-0x2, %rbx
movq (%rdx), %r9
movl $0x3, %eax
movq %rax, -0x50(%rsp)
testb $0x7, %r9b
jne 0x265f4
testb $0x7, %r8b
setne %al
shrl $0x3, %r9d
andl $0x1, %r9d
cmpq %rdi, %r9
cmovgeq %rdi, %r9
setge %r10b
orb %al, %r10b
jne 0x265f4
movq 0x8(%rdx), %r10
leaq (%rbx,%r11), %rax
andl $0x1, %r10d
movb $0x1, %bpl
xorl %r14d, %r14d
movq %r14, %r15
imulq %r10, %r15
addq %r9, %r15
movq %r15, %r12
shrq $0x3f, %r12
addq %r15, %r12
andq $-0x2, %r12
subq %r12, %r15
cmpq %r15, %r11
je 0x26d7f
movl $0x1, %r14d
xorl %r15d, %r15d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x265b7
jmp 0x26d8e
xorl %r15d, %r15d
xorl %eax, %eax
xorl %r9d, %r9d
movq %rsi, %r14
subq %r15, %r14
leaq 0x3(%r14), %r10
testq %r14, %r14
cmovnsq %r14, %r10
andq $-0x4, %r10
addq %r15, %r10
cmpq $0x4, %r14
jl 0x26c40
addq %rbx, %r11
addq $-0x5, %r11
movq %r11, -0x40(%rsp)
leaq (,%r15,8), %r11
movq %r11, -0x60(%rsp)
leaq 0x18(,%r15,8), %r11
movq %r11, -0x68(%rsp)
leaq 0x10(,%r15,8), %r11
movq %r11, -0x70(%rsp)
leaq 0x8(,%r15,8), %r11
movq %r11, -0x78(%rsp)
movq %rdi, %rbp
subq %rax, %rbp
leaq (,%rax,8), %r11
movq %r11, -0x30(%rsp)
leaq (%r8,%rax,8), %r14
movq %r15, -0x38(%rsp)
movq %r15, %r12
movq %rbp, -0x28(%rsp)
movq %rsi, -0x48(%rsp)
movq (%rcx), %r11
movq 0x8(%rcx), %rbx
movq %rbx, %r15
imulq %r12, %r15
leaq 0x1(%r12), %rbp
movq %rbx, %r13
movq %rbp, -0x10(%rsp)
imulq %rbp, %r13
leaq 0x2(%r12), %rsi
movq %rbx, %rbp
movq %rsi, -0x18(%rsp)
imulq %rsi, %rbp
movq %r12, -0x8(%rsp)
leaq 0x3(%r12), %rsi
movq %rsi, -0x20(%rsp)
imulq %rsi, %rbx
movq (%rdx), %r12
movq %r12, -0x58(%rsp)
movq 0x8(%rdx), %r12
movsd (%r11,%r15,8), %xmm1
mulsd %xmm0, %xmm1
movsd (%r11,%r13,8), %xmm2
mulsd %xmm0, %xmm2
movsd (%r11,%rbp,8), %xmm3
mulsd %xmm0, %xmm3
movsd (%r11,%rbx,8), %xmm4
mulsd %xmm0, %xmm4
testq %r9, %r9
jle 0x2679b
movq %r12, %r11
imulq -0x68(%rsp), %r11
movq -0x58(%rsp), %r15
addq %r15, %r11
movq %r12, %rbx
imulq -0x70(%rsp), %rbx
addq %r15, %rbx
movq %r12, %r13
imulq -0x78(%rsp), %r13
addq %r15, %r13
movq %r12, %rbp
imulq -0x60(%rsp), %rbp
addq %r15, %rbp
xorl %r15d, %r15d
movsd (%rbp,%r15,8), %xmm5
mulsd %xmm1, %xmm5
addsd (%r8,%r15,8), %xmm5
movsd %xmm5, (%r8,%r15,8)
movsd (%r13,%r15,8), %xmm6
mulsd %xmm2, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, (%r8,%r15,8)
movsd (%rbx,%r15,8), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm6, %xmm5
movsd %xmm5, (%r8,%r15,8)
movsd (%r11,%r15,8), %xmm6
mulsd %xmm4, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, (%r8,%r15,8)
incq %r15
cmpq %r15, %r9
jne 0x2673f
cmpq %r9, %rax
movq -0x48(%rsp), %rsi
jle 0x26b6f
movapd %xmm1, %xmm5
unpcklpd %xmm1, %xmm5            # xmm5 = xmm5[0],xmm1[0]
movapd %xmm2, %xmm6
unpcklpd %xmm2, %xmm6            # xmm6 = xmm6[0],xmm2[0]
movapd %xmm3, %xmm7
unpcklpd %xmm3, %xmm7            # xmm7 = xmm7[0],xmm3[0]
movapd %xmm4, %xmm8
unpcklpd %xmm4, %xmm8            # xmm8 = xmm8[0],xmm4[0]
movq -0x50(%rsp), %r11
leaq 0x372f9(%rip), %rbx     # 0x5dad0
movslq (%rbx,%r11,4), %r11
addq %rbx, %r11
jmpq *%r11
movq %r12, %r11
imulq -0x68(%rsp), %r11
movq -0x58(%rsp), %rbp
addq %rbp, %r11
movq %r12, %rbx
imulq -0x70(%rsp), %rbx
addq %rbp, %rbx
movq %r12, %r15
imulq -0x78(%rsp), %r15
addq %rbp, %r15
movq %r12, %r13
imulq -0x60(%rsp), %r13
addq %rbp, %r13
movq %r9, %rbp
movapd (%r13,%rbp,8), %xmm9
mulpd %xmm5, %xmm9
movapd (%r15,%rbp,8), %xmm10
mulpd %xmm6, %xmm10
addpd %xmm9, %xmm10
movapd (%rbx,%rbp,8), %xmm9
mulpd %xmm7, %xmm9
movapd (%r11,%rbp,8), %xmm11
mulpd %xmm8, %xmm11
addpd %xmm9, %xmm11
addpd %xmm10, %xmm11
addpd (%r8,%rbp,8), %xmm11
movapd %xmm11, (%r8,%rbp,8)
addq $0x2, %rbp
cmpq %rax, %rbp
jl 0x26819
jmp 0x26b6f
movq %r9, %rbp
cmpq -0x40(%rsp), %r9
jge 0x269c2
movq -0x10(%rsp), %r11
imulq %r12, %r11
movq -0x18(%rsp), %rsi
imulq %r12, %rsi
movq -0x20(%rsp), %r15
imulq %r12, %r15
movq -0x58(%rsp), %rbp
leaq (,%r11,8), %r11
addq %rbp, %r11
leaq (%rbp,%rsi,8), %rbx
movq -0x48(%rsp), %rsi
leaq (%rbp,%r15,8), %r15
movapd -0x18(%r15,%r9,8), %xmm9
movapd -0x10(%rbx,%r9,8), %xmm10
movapd -0x8(%r11,%r9,8), %xmm11
movq %r12, %r11
imulq -0x70(%rsp), %r11
leaq (%r11,%rbp), %r15
addq $0x10, %r15
movq %r12, %r11
imulq -0x60(%rsp), %r11
leaq (%r11,%rbp), %r13
addq $0x10, %r13
movq %r12, %r11
imulq -0x68(%rsp), %r11
leaq (%r11,%rbp), %rbx
addq $0x8, %rbx
movq %r12, %r11
imulq -0x78(%rsp), %r11
addq %rbp, %r11
addq $0x18, %r11
movq %r9, %rbp
movapd -0x10(%r11,%rbp,8), %xmm12
shufpd $0x1, %xmm12, %xmm11    # xmm11 = xmm11[1],xmm12[0]
movapd -0x10(%r13,%rbp,8), %xmm14
mulpd %xmm5, %xmm14
addpd (%r8,%rbp,8), %xmm14
movapd (%r13,%rbp,8), %xmm13
mulpd %xmm5, %xmm13
addpd 0x10(%r8,%rbp,8), %xmm13
mulpd %xmm6, %xmm11
addpd %xmm14, %xmm11
mulpd %xmm7, %xmm10
addpd %xmm11, %xmm10
movapd (%r11,%rbp,8), %xmm11
shufpd $0x1, %xmm11, %xmm12    # xmm12 = xmm12[1],xmm11[0]
mulpd %xmm8, %xmm9
addpd %xmm10, %xmm9
movapd (%r15,%rbp,8), %xmm10
movapd -0x10(%r15,%rbp,8), %xmm14
mulpd %xmm7, %xmm14
movapd -0x10(%rbx,%rbp,8), %xmm15
mulpd %xmm8, %xmm15
movapd %xmm9, (%r8,%rbp,8)
movapd (%rbx,%rbp,8), %xmm9
mulpd %xmm6, %xmm12
addpd %xmm13, %xmm12
addpd %xmm14, %xmm12
addpd %xmm15, %xmm12
movapd %xmm12, 0x10(%r8,%rbp,8)
addq $0x4, %rbp
cmpq -0x40(%rsp), %rbp
jl 0x26912
cmpq %rax, %rbp
jge 0x26b6f
movq %r12, %r11
imulq -0x60(%rsp), %r11
movq -0x58(%rsp), %r13
addq %r13, %r11
movq %r12, %rbx
imulq -0x68(%rsp), %rbx
addq %r13, %rbx
movq %r12, %r15
imulq -0x70(%rsp), %r15
addq %r13, %r15
movq %r12, %r13
imulq -0x78(%rsp), %r13
addq -0x58(%rsp), %r13
movapd (%r11,%rbp,8), %xmm9
mulpd %xmm5, %xmm9
movupd (%r13,%rbp,8), %xmm10
mulpd %xmm6, %xmm10
addpd %xmm9, %xmm10
movupd (%r15,%rbp,8), %xmm9
mulpd %xmm7, %xmm9
movupd (%rbx,%rbp,8), %xmm11
mulpd %xmm8, %xmm11
addpd %xmm9, %xmm11
addpd %xmm10, %xmm11
addpd (%r8,%rbp,8), %xmm11
movapd %xmm11, (%r8,%rbp,8)
addq $0x2, %rbp
cmpq %rax, %rbp
jl 0x26a02
jmp 0x26b6f
movq %r12, %r11
imulq -0x68(%rsp), %r11
movq -0x58(%rsp), %rbp
addq %rbp, %r11
movq %r12, %rbx
imulq -0x70(%rsp), %rbx
addq %rbp, %rbx
movq %r12, %r15
imulq -0x78(%rsp), %r15
addq %rbp, %r15
movq %r12, %r13
imulq -0x60(%rsp), %r13
addq %rbp, %r13
movq %r9, %rbp
movupd (%r13,%rbp,8), %xmm9
mulpd %xmm5, %xmm9
movupd (%r15,%rbp,8), %xmm10
mulpd %xmm6, %xmm10
addpd %xmm9, %xmm10
movupd (%rbx,%rbp,8), %xmm9
mulpd %xmm7, %xmm9
movupd (%r11,%rbp,8), %xmm11
mulpd %xmm8, %xmm11
addpd %xmm9, %xmm11
addpd %xmm10, %xmm11
addpd (%r8,%rbp,8), %xmm11
movapd %xmm11, (%r8,%rbp,8)
addq $0x2, %rbp
cmpq %rax, %rbp
jl 0x26a90
jmp 0x26b6f
movq %r12, %r11
imulq -0x70(%rsp), %r11
movq -0x58(%rsp), %rbp
addq %rbp, %r11
movq %r12, %rbx
imulq -0x60(%rsp), %rbx
addq %rbp, %rbx
movq %r12, %r15
imulq -0x68(%rsp), %r15
addq %rbp, %r15
movq %r12, %r13
imulq -0x78(%rsp), %r13
addq %rbp, %r13
movq %r9, %rbp
movapd (%rbx,%rbp,8), %xmm9
mulpd %xmm5, %xmm9
movupd (%r13,%rbp,8), %xmm10
mulpd %xmm6, %xmm10
addpd %xmm9, %xmm10
movapd (%r11,%rbp,8), %xmm9
mulpd %xmm7, %xmm9
movupd (%r15,%rbp,8), %xmm11
mulpd %xmm8, %xmm11
addpd %xmm9, %xmm11
addpd %xmm10, %xmm11
addpd (%r8,%rbp,8), %xmm11
movapd %xmm11, (%r8,%rbp,8)
addq $0x2, %rbp
cmpq %rax, %rbp
jl 0x26b1e
cmpq %rax, %rdi
movq -0x28(%rsp), %rbp
jle 0x26c11
movq -0x58(%rsp), %r13
addq -0x30(%rsp), %r13
movq %r12, %r11
imulq -0x68(%rsp), %r11
addq %r13, %r11
movq %r12, %rbx
imulq -0x70(%rsp), %rbx
addq %r13, %rbx
movq %r12, %r15
imulq -0x78(%rsp), %r15
addq %r13, %r15
imulq -0x60(%rsp), %r12
addq %r13, %r12
xorl %r13d, %r13d
movsd (%r12,%r13,8), %xmm5
mulsd %xmm1, %xmm5
addsd (%r14,%r13,8), %xmm5
movsd %xmm5, (%r14,%r13,8)
movsd (%r15,%r13,8), %xmm6
mulsd %xmm2, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, (%r14,%r13,8)
movsd (%rbx,%r13,8), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm6, %xmm5
movsd %xmm5, (%r14,%r13,8)
movsd (%r11,%r13,8), %xmm6
mulsd %xmm4, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, (%r14,%r13,8)
incq %r13
cmpq %r13, %rbp
jne 0x26bb7
movq -0x8(%rsp), %r12
addq $0x4, %r12
addq $0x20, -0x68(%rsp)
addq $0x20, -0x70(%rsp)
addq $0x20, -0x78(%rsp)
addq $0x20, -0x60(%rsp)
cmpq %r10, %r12
jl 0x26687
movq -0x38(%rsp), %r15
movq %r15, %r11
cmpq %rsi, %r10
jge 0x26d5f
leaq (,%r10,8), %rbx
movq 0x8(%rcx), %r12
imulq %r10, %r12
movq (%rdx), %r14
movq 0x8(%rdx), %r15
movq (%rcx), %r13
movsd (%r13,%r12,8), %xmm1
mulsd %xmm0, %xmm1
testq %r9, %r9
jle 0x26ca1
movq %r15, %r12
imulq %rbx, %r12
addq %r14, %r12
xorl %r13d, %r13d
movsd (%r12,%r13,8), %xmm2
mulsd %xmm1, %xmm2
addsd (%r8,%r13,8), %xmm2
movsd %xmm2, (%r8,%r13,8)
incq %r13
cmpq %r13, %r9
jne 0x26c83
movq %r15, %r12
imulq %r10, %r12
movapd %xmm1, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
leaq (%r14,%r12,8), %r12
leal (%r12,%r9,8), %ebp
testb $0xf, %bpl
je 0x26cf1
cmpq %rax, %r9
jge 0x26d22
movq %r15, %r12
imulq %rbx, %r12
addq %r14, %r12
movq %r9, %r13
movupd (%r12,%r13,8), %xmm3
mulpd %xmm2, %xmm3
addpd (%r8,%r13,8), %xmm3
movapd %xmm3, (%r8,%r13,8)
addq $0x2, %r13
cmpq %rax, %r13
jl 0x26cd0
jmp 0x26d22
cmpq %rax, %r9
jge 0x26d22
movq %r15, %r12
imulq %rbx, %r12
addq %r14, %r12
movq %r9, %r13
movapd (%r12,%r13,8), %xmm3
mulpd %xmm2, %xmm3
addpd (%r8,%r13,8), %xmm3
movapd %xmm3, (%r8,%r13,8)
addq $0x2, %r13
cmpq %rax, %r13
jl 0x26d03
cmpq %rax, %rdi
jle 0x26d4f
imulq %rbx, %r15
addq %r15, %r14
movq %rax, %r15
movsd (%r14,%r15,8), %xmm2
mulsd %xmm1, %xmm2
addsd (%r8,%r15,8), %xmm2
movsd %xmm2, (%r8,%r15,8)
incq %r15
cmpq %r15, %rdi
jne 0x26d31
incq %r10
addq $0x8, %rbx
cmpq %rsi, %r10
jne 0x26c54
xorl %r15d, %r15d
movq %r11, %rsi
movl $0x0, %r10d
testq %r11, %r11
jne 0x26c40
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rsi, %r14
cmovgeq %rsi, %r14
movq %r14, %r15
movq %r10, -0x50(%rsp)
movq %r11, %r9
jmp 0x265fc