// File: 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
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x56c70
movq $0x4, -0x48(%rbp)
movq $0x2, -0x50(%rbp)
movq $0x1, -0x58(%rbp)
movq $0x1, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x22b50
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
subq -0x70(%rbp), %rcx
andq $-0x2, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
subq $0x4, %rax
subq $0x2, %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movl $0x2, %eax
subq %rdx, %rax
andq $0x1, %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
jne 0x5eef2
xorl %eax, %eax
movl %eax, -0x45c(%rbp)
jmp 0x5ef10
movq -0x88(%rbp), %rdx
movl $0x2, %eax
movl $0x1, %ecx
cmpq $0x1, %rdx
cmovel %ecx, %eax
movl %eax, -0x45c(%rbp)
movl -0x45c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x22b50
movq %rax, -0x98(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0x18(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x5ef5a
movq -0x28(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x5ef6f
movq $0x0, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
jmp 0x5f030
jmp 0x5ef71
xorl %eax, %eax
cmpq $0x2, -0xa0(%rbp)
movb %al, -0x45d(%rbp)
jge 0x5efc4
movq -0x70(%rbp), %rax
movq %rax, -0x468(%rbp)
movq -0x98(%rbp), %rax
movq -0x88(%rbp), %rcx
imulq -0xa0(%rbp), %rcx
addq %rcx, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq -0x468(%rbp), %rax
cmpq %rdx, %rax
setne %al
movb %al, -0x45d(%rbp)
movb -0x45d(%rbp), %al
testb $0x1, %al
jne 0x5efd0
jmp 0x5efe4
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x5ef71
cmpq $0x2, -0xa0(%rbp)
jne 0x5f006
movq $0x3, -0x90(%rbp)
movq $0x0, -0xa0(%rbp)
jmp 0x5f02e
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x37360
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
jmp 0x5f030
movq -0x88(%rbp), %rdx
movl $0x1, %eax
movl $0x3, %ecx
cmpq $0x1, %rdx
cmovel %ecx, %eax
cltq
movq %rax, -0xb0(%rbp)
movq -0x88(%rbp), %rdx
movl $0x3, %eax
movl $0x1, %ecx
cmpq $0x1, %rdx
cmovel %ecx, %eax
cltq
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rax
subq -0xa0(%rbp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
shlq $0x2, %rax
addq -0xa0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
cmpq -0xc0(%rbp), %rax
jge 0x5ff60
xorps %xmm0, %xmm0
movsd %xmm0, -0xd0(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0xd8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0xe0(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0xe8(%rbp)
movq -0x18(%rbp), %rax
movq -0xc8(%rbp), %rcx
imulq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xf0(%rbp)
movq -0x18(%rbp), %rax
movq -0xc8(%rbp), %rcx
addq -0xb0(%rbp), %rcx
imulq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xf8(%rbp)
movq -0x18(%rbp), %rax
movq -0xc8(%rbp), %rcx
addq $0x2, %rcx
imulq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x100(%rbp)
movq -0x18(%rbp), %rax
movq -0xc8(%rbp), %rcx
addq -0xb8(%rbp), %rcx
imulq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x108(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x128(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x4bcd0
movapd %xmm0, -0x120(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x148(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x4bcd0
movapd %xmm0, -0x140(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x168(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x4bcd0
movapd %xmm0, -0x160(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x188(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4bcd0
movapd %xmm0, -0x180(%rbp)
movq $0x0, -0x190(%rbp)
movq -0x190(%rbp), %rax
cmpq -0x70(%rbp), %rax
jge 0x5f30c
movq -0x28(%rbp), %rax
movq -0x190(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x198(%rbp)
movq -0xf0(%rbp), %rsi
movq -0x190(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x39(%rbp), %rdi
leaq -0x198(%rbp), %rdx
callq 0x56da0
addsd -0xd0(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
movq -0xf8(%rbp), %rsi
movq -0x190(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x39(%rbp), %rdi
leaq -0x198(%rbp), %rdx
callq 0x56da0
addsd -0xd8(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
movq -0x100(%rbp), %rsi
movq -0x190(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x39(%rbp), %rdi
leaq -0x198(%rbp), %rdx
callq 0x56da0
addsd -0xe0(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
movq -0x108(%rbp), %rsi
movq -0x190(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x39(%rbp), %rdi
leaq -0x198(%rbp), %rdx
callq 0x56da0
addsd -0xe8(%rbp), %xmm0
movsd %xmm0, -0xe8(%rbp)
movq -0x190(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x190(%rbp)
jmp 0x5f1f8
movq -0x78(%rbp), %rax
cmpq -0x70(%rbp), %rax
jle 0x5fd5c
movq -0x90(%rbp), %rax
movq %rax, -0x470(%rbp)
testq %rax, %rax
je 0x5f358
jmp 0x5f32f
movq -0x470(%rbp), %rax
subq $0x1, %rax
je 0x5f4cf
jmp 0x5f342
movq -0x470(%rbp), %rax
subq $0x2, %rax
je 0x5f646
jmp 0x5fb78
movq -0x70(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rax
cmpq -0x78(%rbp), %rax
jge 0x5f4ca
movq -0x28(%rbp), %rdi
movq -0x1a0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x1b0(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x1a0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x1c0(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
leaq -0x1b0(%rbp), %rdx
leaq -0x120(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x120(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x1a0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x1d0(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
leaq -0x1b0(%rbp), %rdx
leaq -0x140(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x140(%rbp)
movq -0x100(%rbp), %rdi
movq -0x1a0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x1e0(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
leaq -0x1b0(%rbp), %rdx
leaq -0x160(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x160(%rbp)
movq -0x108(%rbp), %rdi
movq -0x1a0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x1f0(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
leaq -0x1b0(%rbp), %rdx
leaq -0x180(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x180(%rbp)
movq -0x1a0(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x1a0(%rbp)
jmp 0x5f363
jmp 0x5fcec
movq -0x70(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movq -0x1f8(%rbp), %rax
cmpq -0x78(%rbp), %rax
jge 0x5f641
movq -0x28(%rbp), %rdi
movq -0x1f8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x210(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x1f8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x220(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x220(%rbp), %rsi
leaq -0x210(%rbp), %rdx
leaq -0x120(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x120(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x1f8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x230(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x230(%rbp), %rsi
leaq -0x210(%rbp), %rdx
leaq -0x140(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x140(%rbp)
movq -0x100(%rbp), %rdi
movq -0x1f8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x240(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x240(%rbp), %rsi
leaq -0x210(%rbp), %rdx
leaq -0x160(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x160(%rbp)
movq -0x108(%rbp), %rdi
movq -0x1f8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x250(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x250(%rbp), %rsi
leaq -0x210(%rbp), %rdx
leaq -0x180(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x180(%rbp)
movq -0x1f8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x1f8(%rbp)
jmp 0x5f4da
jmp 0x5fcec
movq -0x70(%rbp), %rax
movq %rax, -0x258(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x70(%rbp), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x270(%rbp)
movq -0x100(%rbp), %rdi
movq -0x70(%rbp), %rax
subq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x280(%rbp)
movq -0x108(%rbp), %rdi
movq -0x70(%rbp), %rax
subq $0x3, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x290(%rbp)
movq -0x258(%rbp), %rax
cmpq -0x80(%rbp), %rax
jge 0x5fa0a
movq -0x28(%rbp), %rdi
movq -0x258(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x2d0(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x258(%rbp), %rax
subq $0x1, %rax
addq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x2a0(%rbp)
leaq -0x270(%rbp), %rdi
leaq -0x2a0(%rbp), %rsi
callq 0x56ce0
movq -0x100(%rbp), %rdi
movq -0x258(%rbp), %rax
subq $0x2, %rax
addq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x2b0(%rbp)
leaq -0x280(%rbp), %rdi
leaq -0x2b0(%rbp), %rsi
callq 0x56d10
movq -0x108(%rbp), %rdi
movq -0x258(%rbp), %rax
subq $0x3, %rax
addq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x2c0(%rbp)
leaq -0x290(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
callq 0x56d40
movq -0xf0(%rbp), %rdi
movq -0x258(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x2e0(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x2e0(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
leaq -0x120(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x120(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x270(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
leaq -0x140(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x140(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x258(%rbp), %rax
subq $0x1, %rax
addq $0x4, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x270(%rbp)
leaq -0x2a0(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x56ce0
leaq -0x3a(%rbp), %rdi
leaq -0x280(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
leaq -0x160(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x160(%rbp)
movq -0x100(%rbp), %rdi
movq -0x258(%rbp), %rax
subq $0x2, %rax
addq $0x4, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x280(%rbp)
leaq -0x2b0(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x56d10
leaq -0x3a(%rbp), %rdi
leaq -0x290(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
leaq -0x180(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x180(%rbp)
movq -0x108(%rbp), %rdi
movq -0x258(%rbp), %rax
subq $0x3, %rax
addq $0x4, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x290(%rbp)
leaq -0x2c0(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x56d40
movq -0x28(%rbp), %rdi
movq -0x258(%rbp), %rax
addq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x2d0(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x258(%rbp), %rax
addq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x2f0(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x2f0(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
leaq -0x120(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x120(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x2a0(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
leaq -0x140(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x140(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x2b0(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
leaq -0x160(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x160(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
leaq -0x180(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x180(%rbp)
movq -0x258(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x258(%rbp)
jmp 0x5f6ba
jmp 0x5fa0c
movq -0x258(%rbp), %rax
cmpq -0x78(%rbp), %rax
jge 0x5fb73
movq -0x28(%rbp), %rdi
movq -0x258(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x300(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x258(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x310(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x310(%rbp), %rsi
leaq -0x300(%rbp), %rdx
leaq -0x120(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x120(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x258(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x320(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x320(%rbp), %rsi
leaq -0x300(%rbp), %rdx
leaq -0x140(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x140(%rbp)
movq -0x100(%rbp), %rdi
movq -0x258(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x330(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x330(%rbp), %rsi
leaq -0x300(%rbp), %rdx
leaq -0x160(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x160(%rbp)
movq -0x108(%rbp), %rdi
movq -0x258(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x340(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x340(%rbp), %rsi
leaq -0x300(%rbp), %rdx
leaq -0x180(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x180(%rbp)
movq -0x258(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x258(%rbp)
jmp 0x5fa0c
jmp 0x5fcec
movq -0x70(%rbp), %rax
movq %rax, -0x348(%rbp)
movq -0x348(%rbp), %rax
cmpq -0x78(%rbp), %rax
jge 0x5fcea
movq -0x28(%rbp), %rdi
movq -0x348(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x360(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x348(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x370(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x370(%rbp), %rsi
leaq -0x360(%rbp), %rdx
leaq -0x120(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x120(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x348(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x380(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x380(%rbp), %rsi
leaq -0x360(%rbp), %rdx
leaq -0x140(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x140(%rbp)
movq -0x100(%rbp), %rdi
movq -0x348(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x390(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x390(%rbp), %rsi
leaq -0x360(%rbp), %rdx
leaq -0x160(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x160(%rbp)
movq -0x108(%rbp), %rdi
movq -0x348(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x3a0(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x3a0(%rbp), %rsi
leaq -0x360(%rbp), %rdx
leaq -0x180(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x180(%rbp)
movq -0x348(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x348(%rbp)
jmp 0x5fb83
jmp 0x5fcec
leaq -0x120(%rbp), %rdi
callq 0x4cae0
addsd -0xd0(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x4cae0
addsd -0xd8(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x4cae0
addsd -0xe0(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x4cae0
addsd -0xe8(%rbp), %xmm0
movsd %xmm0, -0xe8(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x3a8(%rbp)
movq -0x3a8(%rbp), %rax
cmpq -0x68(%rbp), %rax
jge 0x5fe7b
movq -0x28(%rbp), %rax
movq -0x3a8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x3b0(%rbp)
movq -0xf0(%rbp), %rsi
movq -0x3a8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x39(%rbp), %rdi
leaq -0x3b0(%rbp), %rdx
callq 0x56da0
addsd -0xd0(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
movq -0xf8(%rbp), %rsi
movq -0x3a8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x39(%rbp), %rdi
leaq -0x3b0(%rbp), %rdx
callq 0x56da0
addsd -0xd8(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
movq -0x100(%rbp), %rsi
movq -0x3a8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x39(%rbp), %rdi
leaq -0x3b0(%rbp), %rdx
callq 0x56da0
addsd -0xe0(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
movq -0x108(%rbp), %rsi
movq -0x3a8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x39(%rbp), %rdi
leaq -0x3b0(%rbp), %rdx
callq 0x56da0
addsd -0xe8(%rbp), %xmm0
movsd %xmm0, -0xe8(%rbp)
movq -0x3a8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x3a8(%rbp)
jmp 0x5fd67
movsd -0x38(%rbp), %xmm0
movsd -0xd0(%rbp), %xmm2
movq 0x10(%rbp), %rax
movq -0xc8(%rbp), %rcx
imulq 0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd -0x38(%rbp), %xmm0
movsd -0xd8(%rbp), %xmm2
movq 0x10(%rbp), %rax
movq -0xc8(%rbp), %rcx
addq -0xb0(%rbp), %rcx
imulq 0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd -0x38(%rbp), %xmm0
movsd -0xe0(%rbp), %xmm2
movq 0x10(%rbp), %rax
movq -0xc8(%rbp), %rcx
addq $0x2, %rcx
imulq 0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd -0x38(%rbp), %xmm0
movsd -0xe8(%rbp), %xmm2
movq 0x10(%rbp), %rax
movq -0xc8(%rbp), %rcx
addq -0xb8(%rbp), %rcx
imulq 0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0xc8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0xc8(%rbp)
jmp 0x5f0a7
movq -0x8(%rbp), %rax
movq %rax, -0x3b8(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x3c0(%rbp)
movq -0x3c0(%rbp), %rax
movq %rax, -0x3c8(%rbp)
movq -0x3c8(%rbp), %rax
cmpq -0x3b8(%rbp), %rax
jge 0x60273
xorps %xmm0, %xmm0
movsd %xmm0, -0x3d0(%rbp)
leaq -0x3d0(%rbp), %rdi
callq 0x4bcd0
movapd %xmm0, -0x3e0(%rbp)
movq -0x18(%rbp), %rax
movq -0x3c8(%rbp), %rcx
imulq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x3e8(%rbp)
movq $0x0, -0x3f0(%rbp)
movq -0x3f0(%rbp), %rax
cmpq -0x70(%rbp), %rax
jge 0x60044
movq -0x3e8(%rbp), %rsi
movq -0x3f0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x3f0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq -0x39(%rbp), %rdi
callq 0x56da0
addsd -0x3d0(%rbp), %xmm0
movsd %xmm0, -0x3d0(%rbp)
movq -0x3f0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x3f0(%rbp)
jmp 0x5ffe3
movq -0x78(%rbp), %rax
cmpq -0x70(%rbp), %rax
jle 0x601c1
movq -0x3e8(%rbp), %rax
movq -0x70(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x6010d
movq -0x70(%rbp), %rax
movq %rax, -0x3f8(%rbp)
movq -0x3f8(%rbp), %rax
cmpq -0x78(%rbp), %rax
jge 0x60108
movq -0x3e8(%rbp), %rdi
movq -0x3f8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x410(%rbp)
movq -0x28(%rbp), %rdi
movq -0x3f8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x420(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x410(%rbp), %rsi
leaq -0x420(%rbp), %rdx
leaq -0x3e0(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x3e0(%rbp)
movq -0x3f8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x3f8(%rbp)
jmp 0x6007d
jmp 0x601a5
movq -0x70(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rax
cmpq -0x78(%rbp), %rax
jge 0x601a3
movq -0x3e8(%rbp), %rdi
movq -0x428(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x517b0
movapd %xmm0, -0x440(%rbp)
movq -0x28(%rbp), %rdi
movq -0x428(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4bc80
movapd %xmm0, -0x450(%rbp)
leaq -0x3a(%rbp), %rdi
leaq -0x440(%rbp), %rsi
leaq -0x450(%rbp), %rdx
leaq -0x3e0(%rbp), %rcx
callq 0x56d70
movapd %xmm0, -0x3e0(%rbp)
movq -0x428(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x428(%rbp)
jmp 0x60118
jmp 0x601a5
leaq -0x3e0(%rbp), %rdi
callq 0x4cae0
addsd -0x3d0(%rbp), %xmm0
movsd %xmm0, -0x3d0(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x458(%rbp)
movq -0x458(%rbp), %rax
cmpq -0x68(%rbp), %rax
jge 0x6022d
movq -0x3e8(%rbp), %rsi
movq -0x458(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x458(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq -0x39(%rbp), %rdi
callq 0x56da0
addsd -0x3d0(%rbp), %xmm0
movsd %xmm0, -0x3d0(%rbp)
movq -0x458(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x458(%rbp)
jmp 0x601cc
movsd -0x38(%rbp), %xmm0
movsd -0x3d0(%rbp), %xmm2
movq 0x10(%rbp), %rax
movq -0x3c8(%rbp), %rcx
imulq 0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x3c8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x3c8(%rbp)
jmp 0x5ff87
cmpq $0x0, -0xa0(%rbp)
je 0x602a3
movq $0x0, -0x3c0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x3b8(%rbp)
movq $0x0, -0xa0(%rbp)
jmp 0x602a5
jmp 0x602b3
jmp 0x602a7
movb $0x1, %al
testb $0x1, %al
jne 0x5ff79
jmp 0x602b3
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax)