// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
movq %rdx, %r13
movq %rdi, -0x78(%rsp)
movl %r8d, %r14d
shrl $0x3, %r14d
andl $0x1, %r14d
cmpq %rsi, %r14
cmovgeq %rsi, %r14
testb $0x7, %r8b
cmovneq %rsi, %r14
movq %rsi, %r15
subq %r14, %r15
andq $-0x2, %r15
movl %ecx, %ebx
andl $0x1, %ebx
movl %r8d, %eax
orl %r13d, %eax
movl %r13d, %r10d
shrl $0x3, %r10d
andl $0x1, %r10d
cmpq %rsi, %r10
cmovgeq %rsi, %r10
testb $0x7, %r13b
cmovneq %rsi, %r10
testb $0x7, %al
je 0x26f64
xorl %edx, %edx
movq %rbx, -0x70(%rsp)
xorl %r11d, %r11d
xorl %r9d, %r9d
jmp 0x26fbd
leaq (%r15,%r14), %r11
movabsq $0x3, %rax
movq %rax, -0x70(%rsp)
movabsq $0x2, %r12
xorl %r9d, %r9d
cmpq $0x2, %r9
je 0x26f9f
movq %r10, %rax
cqto
idivq %r12
cmpq %rdx, %r14
je 0x26fa6
incq %r9
addq %rbx, %r10
jmp 0x26f84
movq %r14, %r9
xorl %edx, %edx
jmp 0x26fbd
movq -0x78(%rsp), %rax
cmpq %rax, %r9
cmovgeq %rax, %r9
movq %r9, %rdx
movq %rbx, -0x70(%rsp)
movq %r14, %r9
leaq (%r15,%r14), %rax
addq $-0x5, %rax
movq %rax, -0x30(%rsp)
xorl %edi, %edi
testq %rbx, %rbx
sete %dil
movq %rdi, -0x60(%rsp)
leaq 0x1(%rbx,%rbx), %rax
movq %rax, -0x18(%rsp)
leaq 0x1(,%rdi,2), %rax
movq %rax, -0x20(%rsp)
movq -0x78(%rsp), %rax
subq %rdx, %rax
movabsq $0x4, %r14
movq %rdx, %rdi
movq %rdx, -0x58(%rsp)
cqto
idivq %r14
movq $0x0, -0x38(%rsp)
testq %r9, %r9
movl $0x0, %edx
cmovgq %r9, %rdx
leaq (%rdi,%rax,4), %rax
movq %rdi, %r10
imulq %rcx, %r10
movq %r10, -0x68(%rsp)
leaq (,%r10,8), %r12
addq %r13, %r12
movq %rcx, %r10
shlq $0x5, %r10
movq %r10, -0x28(%rsp)
leaq (%rdi,%rbx,2), %r14
incq %r14
imulq %rcx, %r14
leaq (,%r14,8), %r15
addq %r13, %r15
movq %rcx, %r10
movq %r13, %rcx
leaq 0x2(%rdi), %rbp
imulq %r10, %rbp
leaq (%r13,%rbp,8), %r13
movq -0x60(%rsp), %rbx
leaq (%rdi,%rbx,2), %rbx
incq %rbx
movq %r10, -0x40(%rsp)
imulq %r10, %rbx
leaq (,%r9,8), %r10
movq -0x68(%rsp), %rdi
leaq (%r10,%rdi,8), %rdi
movq %rdi, -0x50(%rsp)
leaq (%r10,%r14,8), %rdi
leaq (%r10,%rbp,8), %r14
leaq (%r10,%rbx,8), %r10
leaq (%rcx,%rbx,8), %rbp
addq %rcx, -0x50(%rsp)
addq %rcx, %rdi
movq %rdi, -0x60(%rsp)
addq %rcx, %r14
movq %r14, -0x68(%rsp)
movq %rcx, -0x48(%rsp)
addq %rcx, %r10
movq %r10, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movq -0x58(%rsp), %rbx
cmpq %rax, %rbx
jge 0x2750a
movq -0x18(%rsp), %rcx
leaq (%rbx,%rcx), %r10
movq %r10, -0x10(%rsp)
imulq -0x40(%rsp), %r10
movq -0x48(%rsp), %rcx
leaq (%rcx,%r10,8), %r10
leaq 0x2(%rbx), %rcx
movq %rcx, -0x8(%rsp)
movq -0x20(%rsp), %rcx
movq %rbx, -0x80(%rsp)
addq %rbx, %rcx
movq %rcx, (%rsp)
xorpd %xmm2, %xmm2
xorl %ebx, %ebx
xorpd %xmm1, %xmm1
cmpq %rbx, %rdx
je 0x27161
movsd (%r8,%rbx,8), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movsd (%r13,%rbx,8), %xmm4
movhpd (%rbp,%rbx,8), %xmm4    # xmm4 = xmm4[0],mem[0]
movsd (%r12,%rbx,8), %xmm5
movhpd (%r15,%rbx,8), %xmm5    # xmm5 = xmm5[0],mem[0]
mulpd %xmm3, %xmm5
mulpd %xmm3, %xmm4
addpd %xmm4, %xmm1
addpd %xmm5, %xmm2
incq %rbx
jmp 0x27124
cmpq %r9, %r11
jle 0x271e4
movq -0x70(%rsp), %rcx
leaq 0x190a6(%rip), %r14     # 0x40218
movslq (%r14,%rcx,4), %rbx
addq %r14, %rbx
jmpq *%rbx
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
xorpd %xmm5, %xmm5
movq %r9, %r10
movq -0x80(%rsp), %rbx
cmpq %r11, %r10
jge 0x2732b
movapd (%r8,%r10,8), %xmm7
movapd (%r12,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm5
movapd (%r15,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm6
movapd (%r13,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm4
mulpd (%rbp,%r10,8), %xmm7
addpd %xmm7, %xmm3
addq $0x2, %r10
jmp 0x27193
movq -0x80(%rsp), %rbx
jmp 0x27356
movapd -0x8(%r10,%r9,8), %xmm7
xorpd %xmm3, %xmm3
movq -0x38(%rsp), %rbx
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
xorpd %xmm5, %xmm5
movq %r9, %r10
movq -0x30(%rsp), %rcx
cmpq %rcx, %r10
jge 0x272bd
movapd 0x8(%r15,%r10,8), %xmm9
shufpd $0x1, %xmm9, %xmm7      # xmm7 = xmm7[1],xmm9[0]
movapd (%r8,%r10,8), %xmm10
movapd 0x10(%r8,%r10,8), %xmm8
movapd (%r12,%r10,8), %xmm11
mulpd %xmm10, %xmm11
addpd %xmm11, %xmm5
mulpd %xmm10, %xmm7
addpd %xmm7, %xmm6
movapd 0x18(%r15,%r10,8), %xmm7
shufpd $0x1, %xmm7, %xmm9      # xmm9 = xmm9[1],xmm7[0]
movapd -0x10(%r13,%r10,8), %xmm11
mulpd %xmm10, %xmm11
addpd %xmm11, %xmm4
mulpd -0x18(%rbp,%r10,8), %xmm10
addpd %xmm10, %xmm3
movapd 0x10(%r12,%r10,8), %xmm10
mulpd %xmm8, %xmm10
addpd %xmm10, %xmm5
mulpd %xmm8, %xmm9
addpd %xmm9, %xmm6
movapd (%r13,%r10,8), %xmm9
mulpd %xmm8, %xmm9
mulpd -0x8(%rbp,%r10,8), %xmm8
addpd %xmm9, %xmm4
addpd %xmm8, %xmm3
addq $0x4, %r10
addq $0x20, %rbx
jmp 0x27212
movq -0x50(%rsp), %rcx
cmpq %r11, %r10
jge 0x27326
movapd (%r8,%r10,8), %xmm7
movapd (%rcx,%rbx), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm5
movq -0x60(%rsp), %r14
movupd (%r14,%rbx), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm6
movq -0x68(%rsp), %r14
movupd (%r14,%rbx), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm4
movq 0x8(%rsp), %r14
movupd (%r14,%rbx), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm3
addq $0x2, %r10
addq $0x10, %rbx
jmp 0x272c2
movq -0x80(%rsp), %rbx
movapd %xmm5, %xmm7
unpcklpd %xmm6, %xmm7            # xmm7 = xmm7[0],xmm6[0]
movapd %xmm4, %xmm8
unpcklpd %xmm3, %xmm8            # xmm8 = xmm8[0],xmm3[0]
unpckhpd %xmm6, %xmm5            # xmm5 = xmm5[1],xmm6[1]
addpd %xmm7, %xmm5
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addpd %xmm8, %xmm4
addpd %xmm4, %xmm1
addpd %xmm5, %xmm2
movq %r11, %r10
cmpq %rsi, %r10
jge 0x27397
movsd (%r8,%r10,8), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movsd (%r13,%r10,8), %xmm4
movhpd (%rbp,%r10,8), %xmm4    # xmm4 = xmm4[0],mem[0]
movsd (%r12,%r10,8), %xmm5
movhpd (%r15,%r10,8), %xmm5    # xmm5 = xmm5[0],mem[0]
mulpd %xmm3, %xmm5
mulpd %xmm3, %xmm4
addpd %xmm4, %xmm1
addpd %xmm5, %xmm2
incq %r10
jmp 0x27359
movq %rbx, %r10
movq 0x50(%rsp), %rcx
imulq %rcx, %r10
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
addsd (%rdi,%r10,8), %xmm3
movsd %xmm3, (%rdi,%r10,8)
movq -0x10(%rsp), %r10
imulq %rcx, %r10
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm0, %xmm2
addsd (%rdi,%r10,8), %xmm2
movsd %xmm2, (%rdi,%r10,8)
movq -0x8(%rsp), %r10
imulq %rcx, %r10
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd (%rdi,%r10,8), %xmm2
movsd %xmm2, (%rdi,%r10,8)
movq (%rsp), %r10
imulq %rcx, %r10
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
mulsd %xmm0, %xmm1
addsd (%rdi,%r10,8), %xmm1
movsd %xmm1, (%rdi,%r10,8)
addq $0x4, %rbx
movq -0x28(%rsp), %rcx
addq %rcx, %r12
addq %rcx, %r15
addq %rcx, %r13
addq %rcx, %rbp
addq %rcx, -0x38(%rsp)
jmp 0x270da
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
xorpd %xmm5, %xmm5
movq %r9, %r10
movq -0x80(%rsp), %rbx
cmpq %r11, %r10
jge 0x2732b
movapd (%r8,%r10,8), %xmm7
movupd (%r12,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm5
movupd (%r15,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm6
movupd (%r13,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm4
movupd (%rbp,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm3
addq $0x2, %r10
jmp 0x27444
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
xorpd %xmm5, %xmm5
movq %r9, %r10
movq -0x80(%rsp), %rbx
cmpq %r11, %r10
jge 0x2732b
movapd (%r8,%r10,8), %xmm7
movapd (%r12,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm5
movupd (%r15,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm6
movapd (%r13,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm4
movupd (%rbp,%r10,8), %xmm8
mulpd %xmm7, %xmm8
addpd %xmm8, %xmm3
addq $0x2, %r10
jmp 0x274b3
movq -0x40(%rsp), %rcx
leaq (,%rcx,8), %r15
movq -0x48(%rsp), %rbp
movq -0x58(%rsp), %r10
movq -0x78(%rsp), %r14
movq %r10, %r12
movq %r15, %r13
imulq %rax, %r13
addq %rbp, %r13
cmpq %r14, %rax
jge 0x27612
movq %rax, %r10
imulq %rcx, %r10
leaq (,%r10,8), %r10
addq %rbp, %r10
xorpd %xmm1, %xmm1
xorl %ebx, %ebx
cmpq %rbx, %rdx
je 0x2756f
movsd (%r13,%rbx,8), %xmm2
mulsd (%r8,%rbx,8), %xmm2
addsd %xmm2, %xmm1
incq %rbx
jmp 0x27554
cmpq %r9, %r11
jle 0x275d0
leal (%r10,%r9,8), %r10d
xorpd %xmm2, %xmm2
testb $0xf, %r10b
je 0x275a1
movq %r9, %r10
cmpq %r11, %r10
jge 0x275c0
movupd (%r13,%r10,8), %xmm3
mulpd (%r8,%r10,8), %xmm3
addpd %xmm3, %xmm2
addq $0x2, %r10
jmp 0x27585
movq %r9, %r10
cmpq %r11, %r10
jge 0x275c0
movapd (%r13,%r10,8), %xmm3
mulpd (%r8,%r10,8), %xmm3
addpd %xmm3, %xmm2
addq $0x2, %r10
jmp 0x275a4
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
addsd %xmm3, %xmm1
movq %r11, %r10
cmpq %rsi, %r10
jge 0x275ee
movsd (%r13,%r10,8), %xmm2
mulsd (%r8,%r10,8), %xmm2
addsd %xmm2, %xmm1
incq %r10
jmp 0x275d3
movq %rax, %r10
imulq 0x50(%rsp), %r10
mulsd %xmm0, %xmm1
addsd (%rdi,%r10,8), %xmm1
movsd %xmm1, (%rdi,%r10,8)
incq %rax
addq %r15, %r13
jmp 0x27533
movl $0x0, %r10d
movq %r12, %r14
movl $0x0, %eax
testq %r12, %r12
jne 0x27526
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq