// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/Eigen/src/Core/products/GeneralMatrixVector.h
// Function: Eigen::internal::general_matrix_vector_product<long, double, 1, false, double, false, 0>::run(long, long, double const*, long, double const*, long, double*, long, double)
EIGEN_DONT_INLINE void general_matrix_vector_product<Index,LhsScalar,RowMajor,ConjugateLhs,RhsScalar,ConjugateRhs,Version>::run(
  Index rows, Index cols,
  const LhsScalar* lhs, Index lhsStride,
  const RhsScalar* rhs, Index rhsIncr,
  ResScalar* res, Index resIncr,
  ResScalar alpha)
{
  EIGEN_UNUSED_VARIABLE(rhsIncr);
  eigen_internal_assert(rhsIncr==1);
  #ifdef _EIGEN_ACCUMULATE_PACKETS
  #error _EIGEN_ACCUMULATE_PACKETS has already been defined
  #endif

  #define _EIGEN_ACCUMULATE_PACKETS(A0,A13,A2) {\
    RhsPacket b = pload<RhsPacket>(&rhs[j]); \
    ptmp0 = pcj.pmadd(EIGEN_CAT(ploa,A0) <LhsPacket>(&lhs0[j]), b, ptmp0); \
    ptmp1 = pcj.pmadd(EIGEN_CAT(ploa,A13)<LhsPacket>(&lhs1[j]), b, ptmp1); \
    ptmp2 = pcj.pmadd(EIGEN_CAT(ploa,A2) <LhsPacket>(&lhs2[j]), b, ptmp2); \
    ptmp3 = pcj.pmadd(EIGEN_CAT(ploa,A13)<LhsPacket>(&lhs3[j]), b, ptmp3); }

  conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
  conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj;

  enum { AllAligned=0, EvenAligned=1, FirstAligned=2, NoneAligned=3 };
  const Index rowsAtOnce = 4;
  const Index peels = 2;
  const Index RhsPacketAlignedMask = RhsPacketSize-1;
  const Index LhsPacketAlignedMask = LhsPacketSize-1;
//   const Index PeelAlignedMask = RhsPacketSize*peels-1;
  const Index depth = cols;

  // 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
  // if that's not the case then vectorization is discarded, see below.
  Index alignedStart = internal::first_aligned(rhs, depth);
  Index alignedSize = RhsPacketSize>1 ? alignedStart + ((depth-alignedStart) & ~RhsPacketAlignedMask) : 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 = internal::first_aligned(lhs,depth);

  // find how many rows do we have to skip to be aligned with rhs (if possible)
  Index skipRows = 0;
  // if the data cannot be aligned (TODO add some compile time tests when possible, e.g. for floats)
  if( (sizeof(LhsScalar)!=sizeof(RhsScalar)) || (size_t(lhs)%sizeof(LhsScalar)) || (size_t(rhs)%sizeof(RhsScalar)) )
  {
    alignedSize = 0;
    alignedStart = 0;
  }
  else if (LhsPacketSize>1)
  {
    eigen_internal_assert(size_t(lhs+lhsAlignmentOffset)%sizeof(LhsPacket)==0  || depth<LhsPacketSize);

    while (skipRows<LhsPacketSize &&
           alignedStart != ((lhsAlignmentOffset + alignmentStep*skipRows)%LhsPacketSize))
      ++skipRows;
    if (skipRows==LhsPacketSize)
    {
      // nothing can be aligned, no need to skip any column
      alignmentPattern = NoneAligned;
      skipRows = 0;
    }
    else
    {
      skipRows = (std::min)(skipRows,Index(rows));
      // note that the skiped columns are processed later.
    }
    eigen_internal_assert(  alignmentPattern==NoneAligned
                      || LhsPacketSize==1
                      || (skipRows + rowsAtOnce >= rows)
                      || LhsPacketSize > depth
                      || (size_t(lhs+alignedStart+lhsStride*skipRows)%sizeof(LhsPacket))==0);
  }
  else if(Vectorizable)
  {
    alignedStart = 0;
    alignedSize = depth;
    alignmentPattern = AllAligned;
  }

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

  Index rowBound = ((rows-skipRows)/rowsAtOnce)*rowsAtOnce + skipRows;
  for (Index i=skipRows; i<rowBound; i+=rowsAtOnce)
  {
    EIGEN_ALIGN16 ResScalar tmp0 = ResScalar(0);
    ResScalar tmp1 = ResScalar(0), tmp2 = ResScalar(0), tmp3 = ResScalar(0);

    // this helps the compiler generating good binary code
    const LhsScalar *lhs0 = lhs + i*lhsStride,     *lhs1 = lhs + (i+offset1)*lhsStride,
                    *lhs2 = lhs + (i+2)*lhsStride, *lhs3 = lhs + (i+offset3)*lhsStride;

    if (Vectorizable)
    {
      /* explicit vectorization */
      ResPacket ptmp0 = pset1<ResPacket>(ResScalar(0)), ptmp1 = pset1<ResPacket>(ResScalar(0)),
                ptmp2 = pset1<ResPacket>(ResScalar(0)), ptmp3 = pset1<ResPacket>(ResScalar(0));

      // process initial unaligned coeffs
      // FIXME this loop get vectorized by the compiler !
      for (Index j=0; j<alignedStart; ++j)
      {
        RhsScalar b = rhs[j];
        tmp0 += cj.pmul(lhs0[j],b); tmp1 += cj.pmul(lhs1[j],b);
        tmp2 += cj.pmul(lhs2[j],b); tmp3 += cj.pmul(lhs3[j],b);
      }

      if (alignedSize>alignedStart)
      {
        switch(alignmentPattern)
        {
          case AllAligned:
            for (Index j = alignedStart; j<alignedSize; j+=RhsPacketSize)
              _EIGEN_ACCUMULATE_PACKETS(d,d,d);
            break;
          case EvenAligned:
            for (Index j = alignedStart; j<alignedSize; j+=RhsPacketSize)
              _EIGEN_ACCUMULATE_PACKETS(d,du,d);
            break;
          case FirstAligned:
          {
            Index j = alignedStart;
            if (peels>1)
            {
              /* Here we proccess 4 rows with with two peeled iterations to hide
               * the overhead of unaligned loads. Moreover unaligned loads are handled
               * using special shift/move operations between the two aligned packets
               * overlaping the desired unaligned packet. This is *much* more efficient
               * than basic unaligned loads.
               */
              LhsPacket A01, A02, A03, A11, A12, A13;
              A01 = pload<LhsPacket>(&lhs1[alignedStart-1]);
              A02 = pload<LhsPacket>(&lhs2[alignedStart-2]);
              A03 = pload<LhsPacket>(&lhs3[alignedStart-3]);

              for (; j<peeledSize; j+=peels*RhsPacketSize)
              {
                RhsPacket b = pload<RhsPacket>(&rhs[j]);
                A11 = pload<LhsPacket>(&lhs1[j-1+LhsPacketSize]);  palign<1>(A01,A11);
                A12 = pload<LhsPacket>(&lhs2[j-2+LhsPacketSize]);  palign<2>(A02,A12);
                A13 = pload<LhsPacket>(&lhs3[j-3+LhsPacketSize]);  palign<3>(A03,A13);

                ptmp0 = pcj.pmadd(pload<LhsPacket>(&lhs0[j]), b, ptmp0);
                ptmp1 = pcj.pmadd(A01, b, ptmp1);
                A01 = pload<LhsPacket>(&lhs1[j-1+2*LhsPacketSize]);  palign<1>(A11,A01);
                ptmp2 = pcj.pmadd(A02, b, ptmp2);
                A02 = pload<LhsPacket>(&lhs2[j-2+2*LhsPacketSize]);  palign<2>(A12,A02);
                ptmp3 = pcj.pmadd(A03, b, ptmp3);
                A03 = pload<LhsPacket>(&lhs3[j-3+2*LhsPacketSize]);  palign<3>(A13,A03);

                b = pload<RhsPacket>(&rhs[j+RhsPacketSize]);
                ptmp0 = pcj.pmadd(pload<LhsPacket>(&lhs0[j+LhsPacketSize]), b, ptmp0);
                ptmp1 = pcj.pmadd(A11, b, ptmp1);
                ptmp2 = pcj.pmadd(A12, b, ptmp2);
                ptmp3 = pcj.pmadd(A13, b, ptmp3);
              }
            }
            for (; j<alignedSize; j+=RhsPacketSize)
              _EIGEN_ACCUMULATE_PACKETS(d,du,du);
            break;
          }
          default:
            for (Index j = alignedStart; j<alignedSize; j+=RhsPacketSize)
              _EIGEN_ACCUMULATE_PACKETS(du,du,du);
            break;
        }
        tmp0 += predux(ptmp0);
        tmp1 += predux(ptmp1);
        tmp2 += predux(ptmp2);
        tmp3 += predux(ptmp3);
      }
    } // end explicit vectorization

    // process remaining coeffs (or all if no explicit vectorization)
    // FIXME this loop get vectorized by the compiler !
    for (Index j=alignedSize; j<depth; ++j)
    {
      RhsScalar b = rhs[j];
      tmp0 += cj.pmul(lhs0[j],b); tmp1 += cj.pmul(lhs1[j],b);
      tmp2 += cj.pmul(lhs2[j],b); tmp3 += cj.pmul(lhs3[j],b);
    }
    res[i*resIncr]            += alpha*tmp0;
    res[(i+offset1)*resIncr]  += alpha*tmp1;
    res[(i+2)*resIncr]        += alpha*tmp2;
    res[(i+offset3)*resIncr]  += alpha*tmp3;
  }

  // process remaining first and last rows (at most columnsAtOnce-1)
  Index end = rows;
  Index start = rowBound;
  do
  {
    for (Index i=start; i<end; ++i)
    {
      EIGEN_ALIGN16 ResScalar tmp0 = ResScalar(0);
      ResPacket ptmp0 = pset1<ResPacket>(tmp0);
      const LhsScalar* lhs0 = lhs + i*lhsStride;
      // process first unaligned result's coeffs
      // FIXME this loop get vectorized by the compiler !
      for (Index j=0; j<alignedStart; ++j)
        tmp0 += cj.pmul(lhs0[j], rhs[j]);

      if (alignedSize>alignedStart)
      {
        // process aligned rhs coeffs
        if ((size_t(lhs0+alignedStart)%sizeof(LhsPacket))==0)
          for (Index j = alignedStart;j<alignedSize;j+=RhsPacketSize)
            ptmp0 = pcj.pmadd(pload<LhsPacket>(&lhs0[j]), pload<RhsPacket>(&rhs[j]), ptmp0);
        else
          for (Index j = alignedStart;j<alignedSize;j+=RhsPacketSize)
            ptmp0 = pcj.pmadd(ploadu<LhsPacket>(&lhs0[j]), pload<RhsPacket>(&rhs[j]), ptmp0);
        tmp0 += predux(ptmp0);
      }

      // process remaining scalars
      // FIXME this loop get vectorized by the compiler !
      for (Index j=alignedSize; j<depth; ++j)
        tmp0 += cj.pmul(lhs0[j], rhs[j]);
      res[i*resIncr] += alpha*tmp0;
    }
    if (skipRows)
    {
      start = 0;
      end = skipRows;
      skipRows = 0;
    }
    else
      break;
  } while(Vectorizable);

  #undef _EIGEN_ACCUMULATE_PACKETS
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x68(%rsp)
movl %r8d, %r12d
shrl $0x3, %r12d
andl $0x1, %r12d
cmpq %rsi, %r12
cmovgeq %rsi, %r12
testb $0x7, %r8b
cmovneq %rsi, %r12
movq %rsi, %r13
subq %r12, %r13
andq $-0x2, %r13
movl %ecx, %r10d
andl $0x1, %r10d
movl %r8d, %eax
orl %edx, %eax
movl %edx, %r9d
shrl $0x3, %r9d
andl $0x1, %r9d
cmpq %rsi, %r9
cmovgeq %rsi, %r9
movq %rdx, -0x70(%rsp)
testb $0x7, %dl
cmovneq %rsi, %r9
testb $0x7, %al
je 0x2c183
xorl %ecx, %ecx
movq %r10, -0x60(%rsp)
xorl %eax, %eax
xorl %r9d, %r9d
jmp 0x2c1df
leaq (%r12,%r13), %rax
movb $0x1, %bl
xorl %r11d, %r11d
movq %r11, %r14
imulq %r10, %r14
addq %r9, %r14
movq %r14, %r15
shrq $0x3f, %r15
addq %r14, %r15
andq $-0x2, %r15
subq %r15, %r14
cmpq %r14, %r12
je 0x2c1cd
movl $0x1, %r11d
testb $0x1, %bl
movl $0x0, %ebx
jne 0x2c18c
movl $0x3, %ecx
movq %rcx, -0x60(%rsp)
movq %r12, %r9
xorl %ecx, %ecx
jmp 0x2c1df
cmpq %rdi, %r11
cmovgeq %rdi, %r11
movq %r11, %rcx
movq %r10, -0x60(%rsp)
movq %r12, %r9
xorl %r14d, %r14d
testq %r10, %r10
sete %bpl
movq %rdi, -0x20(%rsp)
movq %rdi, %r15
subq %rcx, %r15
leaq 0x3(%r15), %rbx
testq %r15, %r15
cmovnsq %r15, %rbx
andq $-0x4, %rbx
movq %rcx, -0x50(%rsp)
addq %rcx, %rbx
cmpq $0x4, %r15
jl 0x2c751
leaq (%r12,%r13), %rcx
addq $-0x5, %rcx
movq %rcx, -0x48(%rsp)
leaq 0x1(%r10,%r10), %r12
movb %bpl, %r14b
leaq 0x1(%r14,%r14), %rdx
movq -0x50(%rsp), %rbp
movq %rdx, -0x8(%rsp)
leaq (%rdx,%rbp), %rdi
movq -0x68(%rsp), %r10
imulq %r10, %rdi
movq -0x70(%rsp), %rcx
leaq (%rcx,%rdi,8), %r15
movq %r10, %rdx
shlq $0x5, %rdx
movq %rdx, -0x10(%rsp)
leaq 0x2(%rbp), %r11
imulq %r10, %r11
leaq (%rcx,%r11,8), %rdx
movq %rdx, -0x58(%rsp)
movq %r12, (%rsp)
leaq (%r12,%rbp), %rdx
imulq %r10, %rdx
movq %rdx, -0x80(%rsp)
leaq (%rcx,%rdx,8), %r12
movq %rbp, %r14
imulq %r10, %r14
leaq (%rcx,%r14,8), %r13
movq %rsi, %r10
subq %rax, %r10
movq %r10, -0x40(%rsp)
leaq (,%rax,8), %r10
leaq (%r10,%rdi,8), %rdx
addq %rcx, %rdx
movq %rdx, -0x78(%rsp)
leaq (%r10,%r11,8), %rdx
addq %rcx, %rdx
movq -0x80(%rsp), %rdi
leaq (%r10,%rdi,8), %r11
addq %rcx, %r11
leaq (%r10,%r14,8), %rdi
movq %rdx, %r14
movq -0x78(%rsp), %rdx
addq %rcx, %rdi
leaq (%r8,%rax,8), %rcx
movq %rcx, -0x18(%rsp)
movq %rbp, -0x80(%rsp)
movq %rdi, -0x38(%rsp)
movq %r11, -0x30(%rsp)
movq %r14, -0x28(%rsp)
movq %rdx, -0x78(%rsp)
xorpd %xmm2, %xmm2
testq %r9, %r9
jle 0x2c341
xorl %r10d, %r10d
xorpd %xmm1, %xmm1
movq -0x58(%rsp), %rdi
movsd (%r8,%r10,8), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movsd (%rdi,%r10,8), %xmm4
movhpd (%r15,%r10,8), %xmm4    # xmm4 = xmm4[0],mem[0]
movsd (%r13,%r10,8), %xmm5
movhpd (%r12,%r10,8), %xmm5    # xmm5 = xmm5[0],mem[0]
mulpd %xmm3, %xmm5
addpd %xmm5, %xmm2
mulpd %xmm3, %xmm4
addpd %xmm4, %xmm1
incq %r10
cmpq %r10, %r9
jne 0x2c304
jmp 0x2c34a
xorpd %xmm1, %xmm1
movq -0x58(%rsp), %rdi
movq (%rsp), %rcx
movq -0x80(%rsp), %rdx
leaq (%rdx,%rcx), %r11
cmpq %r9, %rax
jle 0x2c618
movq -0x60(%rsp), %rcx
leaq 0x1bec8(%rip), %rdx     # 0x48234
movslq (%rdx,%rcx,4), %r10
addq %rdx, %r10
jmpq *%r10
xorpd %xmm3, %xmm3
movq %r9, %r10
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
movapd (%r8,%r10,8), %xmm7
movapd (%r13,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm3
movapd (%r12,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm5
movapd (%rdi,%r10,8), %xmm8
mulpd %xmm7, %xmm8
mulpd (%r15,%r10,8), %xmm7
addpd %xmm8, %xmm4
addpd %xmm7, %xmm6
addq $0x2, %r10
cmpq %rax, %r10
jl 0x2c389
jmp 0x2c5ed
xorpd %xmm6, %xmm6
xorpd %xmm4, %xmm4
xorpd %xmm5, %xmm5
xorpd %xmm3, %xmm3
movq %r9, %r10
cmpq -0x48(%rsp), %r9
jge 0x2c51b
movq %r11, %r10
imulq -0x68(%rsp), %r10
movq -0x70(%rsp), %rcx
leaq (%rcx,%r10,8), %r10
movq -0x48(%rsp), %rcx
movapd -0x8(%r10,%r9,8), %xmm7
movq %r9, %r10
xorpd %xmm11, %xmm11
xorpd %xmm10, %xmm10
movapd 0x8(%r12,%r10,8), %xmm5
shufpd $0x1, %xmm5, %xmm7      # xmm7 = xmm7[1],xmm5[0]
movapd (%r8,%r10,8), %xmm9
movapd 0x10(%r8,%r10,8), %xmm6
movapd (%r13,%r10,8), %xmm12
mulpd %xmm9, %xmm12
addpd %xmm3, %xmm12
mulpd %xmm9, %xmm7
addpd %xmm11, %xmm7
movapd 0x18(%r12,%r10,8), %xmm8
shufpd $0x1, %xmm8, %xmm5      # xmm5 = xmm5[1],xmm8[0]
movapd -0x10(%rdi,%r10,8), %xmm11
mulpd %xmm9, %xmm11
addpd %xmm4, %xmm11
mulpd -0x18(%r15,%r10,8), %xmm9
addpd %xmm10, %xmm9
movapd 0x10(%r13,%r10,8), %xmm3
mulpd %xmm6, %xmm3
addpd %xmm12, %xmm3
mulpd %xmm6, %xmm5
addpd %xmm7, %xmm5
movapd (%rdi,%r10,8), %xmm4
mulpd %xmm6, %xmm4
addpd %xmm11, %xmm4
mulpd -0x8(%r15,%r10,8), %xmm6
addpd %xmm9, %xmm6
addq $0x4, %r10
movapd %xmm5, %xmm11
movapd %xmm6, %xmm10
movapd %xmm8, %xmm7
cmpq %rcx, %r10
jl 0x2c421
jmp 0x2c51b
movapd (%r8,%r10,8), %xmm7
movapd (%r13,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm3
movupd (%r12,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm5
movupd (%rdi,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm4
movupd (%r15,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm6
addq $0x2, %r10
cmpq %rax, %r10
jl 0x2c4d0
jmp 0x2c5ed
xorpd %xmm3, %xmm3
movq %r9, %r10
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
movapd (%r8,%r10,8), %xmm7
movupd (%r13,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm3
movupd (%r12,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm5
movupd (%rdi,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm4
movupd (%r15,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm6
addq $0x2, %r10
cmpq %rax, %r10
jl 0x2c538
jmp 0x2c5ed
xorpd %xmm3, %xmm3
movq %r9, %r10
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
movapd (%r8,%r10,8), %xmm7
movapd (%r13,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm3
movupd (%r12,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm5
movapd (%rdi,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm4
movupd (%r15,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm6
addq $0x2, %r10
cmpq %rax, %r10
jl 0x2c59d
movapd %xmm3, %xmm7
unpcklpd %xmm5, %xmm7            # xmm7 = xmm7[0],xmm5[0]
movapd %xmm4, %xmm8
unpcklpd %xmm6, %xmm8            # xmm8 = xmm8[0],xmm6[0]
unpckhpd %xmm5, %xmm3            # xmm3 = xmm3[1],xmm5[1]
addpd %xmm7, %xmm3
unpckhpd %xmm6, %xmm4            # xmm4 = xmm4[1],xmm6[1]
addpd %xmm8, %xmm4
addpd %xmm4, %xmm1
addpd %xmm3, %xmm2
movq -0x40(%rsp), %rcx
movq %r15, 0x10(%rsp)
cmpq %rax, %rsi
movq %r11, 0x8(%rsp)
jle 0x2c684
xorl %r10d, %r10d
movq -0x78(%rsp), %rdx
movq -0x28(%rsp), %r14
movq -0x30(%rsp), %r11
movq -0x38(%rsp), %rdi
movq -0x18(%rsp), %r15
movsd (%r15,%r10,8), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movsd (%r14,%r10,8), %xmm4
movhpd (%rdx,%r10,8), %xmm4    # xmm4 = xmm4[0],mem[0]
movsd (%rdi,%r10,8), %xmm5
movhpd (%r11,%r10,8), %xmm5    # xmm5 = xmm5[0],mem[0]
mulpd %xmm3, %xmm5
addpd %xmm5, %xmm2
mulpd %xmm3, %xmm4
addpd %xmm4, %xmm1
incq %r10
cmpq %r10, %rcx
jne 0x2c648
jmp 0x2c698
movq -0x78(%rsp), %rdx
movq -0x28(%rsp), %r14
movq -0x30(%rsp), %r11
movq -0x38(%rsp), %rdi
movq -0x80(%rsp), %rbp
movq %rbp, %r10
movq 0x58(%rsp), %r15
imulq %r15, %r10
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
movq 0x50(%rsp), %rcx
addsd (%rcx,%r10,8), %xmm3
movsd %xmm3, (%rcx,%r10,8)
movq 0x8(%rsp), %r10
imulq %r15, %r10
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm0, %xmm2
addsd (%rcx,%r10,8), %xmm2
movsd %xmm2, (%rcx,%r10,8)
leaq 0x2(%rbp), %r10
imulq %r15, %r10
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd (%rcx,%r10,8), %xmm2
movsd %xmm2, (%rcx,%r10,8)
movq -0x8(%rsp), %r10
addq %rbp, %r10
imulq %r15, %r10
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
mulsd %xmm0, %xmm1
addsd (%rcx,%r10,8), %xmm1
movsd %xmm1, (%rcx,%r10,8)
addq $0x4, %rbp
movq -0x10(%rsp), %rcx
movq 0x10(%rsp), %r15
addq %rcx, %r15
addq %rcx, -0x58(%rsp)
addq %rcx, %r12
addq %rcx, %r13
addq %rcx, %rdx
addq %rcx, %r14
addq %rcx, %r11
addq %rcx, %rdi
movq %rbp, -0x80(%rsp)
cmpq %rbx, %rbp
jl 0x2c2db
movq -0x68(%rsp), %r15
leaq (,%r15,8), %rcx
movq -0x70(%rsp), %r12
movq 0x58(%rsp), %r13
movq -0x50(%rsp), %r10
movq -0x20(%rsp), %r11
movq 0x50(%rsp), %rdi
movq %r10, %rdx
cmpq %r11, %rbx
jge 0x2c85c
movq %rcx, %r10
imulq %rbx, %r10
addq %r12, %r10
xorpd %xmm1, %xmm1
testq %r9, %r9
jle 0x2c7b1
xorl %r14d, %r14d
movsd (%r10,%r14,8), %xmm2
mulsd (%r8,%r14,8), %xmm2
addsd %xmm2, %xmm1
incq %r14
cmpq %r14, %r9
jne 0x2c799
cmpq %r9, %rax
jle 0x2c816
movq %rbx, %r14
imulq %r15, %r14
leaq (%r12,%r14,8), %r14
leal (%r14,%r9,8), %ebp
xorpd %xmm2, %xmm2
movq %r9, %r14
testb $0xf, %bpl
je 0x2c7ed
movupd (%r10,%r14,8), %xmm3
mulpd (%r8,%r14,8), %xmm3
addpd %xmm3, %xmm2
addq $0x2, %r14
cmpq %rax, %r14
jl 0x2c7d2
jmp 0x2c806
movapd (%r10,%r14,8), %xmm3
mulpd (%r8,%r14,8), %xmm3
addpd %xmm3, %xmm2
addq $0x2, %r14
cmpq %rax, %r14
jl 0x2c7ed
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
addsd %xmm3, %xmm1
movq %rax, %r14
cmpq %rax, %rsi
jle 0x2c836
movsd (%r10,%r14,8), %xmm2
mulsd (%r8,%r14,8), %xmm2
addsd %xmm2, %xmm1
incq %r14
cmpq %r14, %rsi
jne 0x2c81e
movq %rbx, %r14
imulq %r13, %r14
mulsd %xmm0, %xmm1
addsd (%rdi,%r14,8), %xmm1
movsd %xmm1, (%rdi,%r14,8)
incq %rbx
addq %rcx, %r10
cmpq %r11, %rbx
jne 0x2c78d
movl $0x0, %r10d
movq %rdx, %r11
movl $0x0, %ebx
testq %rdx, %rdx
jne 0x2c777
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq