// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xca0, %rsp            # imm = 0xCA0
movq %rdi, -0x540(%rbp)
movq %rsi, -0x548(%rbp)
movq %rdx, -0x550(%rbp)
movq %rcx, -0x558(%rbp)
movq %r8, -0x560(%rbp)
movq %r9, -0x568(%rbp)
movsd %xmm0, -0x570(%rbp)
leaq -0x568(%rbp), %rdi
callq 0x38b90
movq $0x4, -0x580(%rbp)
movq $0x2, -0x588(%rbp)
movq $0x1, -0x590(%rbp)
movq $0x1, -0x598(%rbp)
movq -0x540(%rbp), %rax
movq %rax, -0x5a0(%rbp)
movq -0x550(%rbp), %rdi
callq 0x667b0
movq %rax, -0x5a8(%rbp)
movq -0x560(%rbp), %rdi
movq -0x5a0(%rbp), %rsi
callq 0x31120
movq %rax, -0x5b0(%rbp)
movq -0x5b0(%rbp), %rax
movq -0x5a0(%rbp), %rcx
subq -0x5b0(%rbp), %rcx
andq $-0x2, %rcx
addq %rcx, %rax
movq %rax, -0x5b8(%rbp)
movq -0x5b8(%rbp), %rax
subq $0x4, %rax
subq $0x2, %rax
addq $0x1, %rax
movq %rax, -0x5c0(%rbp)
movq -0x5a8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movl $0x2, %eax
subq %rdx, %rax
andq $0x1, %rax
movq %rax, -0x5c8(%rbp)
cmpq $0x0, -0x5c8(%rbp)
jne 0x64505
xorl %eax, %eax
movl %eax, -0xc4c(%rbp)
jmp 0x64523
movq -0x5c8(%rbp), %rdx
movl $0x2, %eax
movl $0x1, %ecx
cmpq $0x1, %rdx
cmovel %ecx, %eax
movl %eax, -0xc4c(%rbp)
movl -0xc4c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x5d0(%rbp)
movq -0x550(%rbp), %rdi
movq -0x5a0(%rbp), %rsi
callq 0x30f90
movq %rax, -0x5d8(%rbp)
movq $0x0, -0x5e0(%rbp)
cmpq $0x0, -0x5d8(%rbp)
jl 0x64582
movq -0x5d8(%rbp), %rax
cmpq -0x5a0(%rbp), %rax
je 0x64582
movq -0x560(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x645a8
movq $0x0, -0x5b8(%rbp)
movq $0x0, -0x5b0(%rbp)
movq $0x3, -0x5d0(%rbp)
jmp 0x64661
jmp 0x645aa
xorl %eax, %eax
cmpq $0x2, -0x5e0(%rbp)
movb %al, -0xc4d(%rbp)
jge 0x64600
movq -0x5b0(%rbp), %rax
movq %rax, -0xc58(%rbp)
movq -0x5d8(%rbp), %rax
movq -0x5c8(%rbp), %rcx
imulq -0x5e0(%rbp), %rcx
addq %rcx, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq -0xc58(%rbp), %rax
cmpq %rdx, %rax
setne %al
movb %al, -0xc4d(%rbp)
movb -0xc4d(%rbp), %al
testb $0x1, %al
jne 0x6460c
jmp 0x64620
movq -0x5e0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x5e0(%rbp)
jmp 0x645aa
cmpq $0x2, -0x5e0(%rbp)
jne 0x64642
movq $0x3, -0x5d0(%rbp)
movq $0x0, -0x5e0(%rbp)
jmp 0x6465f
leaq -0x5e0(%rbp), %rdi
leaq -0x548(%rbp), %rsi
callq 0x2b810
movq (%rax), %rax
movq %rax, -0x5e0(%rbp)
jmp 0x64661
xorl %eax, %eax
cmpq $0x2, -0x5d0(%rbp)
movb %al, -0xc59(%rbp)
jne 0x64684
cmpq $0x1, -0x5c8(%rbp)
sete %al
movb %al, -0xc59(%rbp)
movb -0xc59(%rbp), %dl
movl $0x1, %eax
movl $0x3, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
movq %rax, -0x5e8(%rbp)
xorl %eax, %eax
cmpq $0x2, -0x5d0(%rbp)
movb %al, -0xc5a(%rbp)
jne 0x646c6
cmpq $0x1, -0x5c8(%rbp)
sete %al
movb %al, -0xc5a(%rbp)
movb -0xc5a(%rbp), %dl
movl $0x3, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
movq %rax, -0x5f0(%rbp)
movq -0x548(%rbp), %rax
subq -0x5e0(%rbp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
shlq $0x2, %rax
addq -0x5e0(%rbp), %rax
movq %rax, -0x5f8(%rbp)
movq -0x5e0(%rbp), %rax
movq %rax, -0x600(%rbp)
movq -0x600(%rbp), %rax
cmpq -0x5f8(%rbp), %rax
jge 0x661e4
movsd -0x570(%rbp), %xmm0
movq -0x558(%rbp), %rcx
movq -0x600(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x58(%rbp), %rsi
movq (%rsi), %rax
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x618(%rbp)
leaq -0x618(%rbp), %rdi
callq 0x17f60
movapd %xmm0, -0x610(%rbp)
movsd -0x570(%rbp), %xmm0
movq -0x558(%rbp), %rcx
movq -0x600(%rbp), %rax
addq -0x5e8(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq %rax, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x70(%rbp), %rsi
movq (%rsi), %rax
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x638(%rbp)
leaq -0x638(%rbp), %rdi
callq 0x17f60
movapd %xmm0, -0x630(%rbp)
movsd -0x570(%rbp), %xmm0
movq -0x558(%rbp), %rcx
movq -0x600(%rbp), %rax
addq $0x2, %rax
movq %rcx, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x88(%rbp), %rsi
movq (%rsi), %rax
movq -0x98(%rbp), %rcx
movq -0x90(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x658(%rbp)
leaq -0x658(%rbp), %rdi
callq 0x17f60
movapd %xmm0, -0x650(%rbp)
movsd -0x570(%rbp), %xmm0
movq -0x558(%rbp), %rcx
movq -0x600(%rbp), %rax
addq -0x5f0(%rbp), %rax
movq %rcx, -0xa0(%rbp)
movq %rax, -0xa8(%rbp)
movq $0x0, -0xb0(%rbp)
movq -0xa0(%rbp), %rsi
movq (%rsi), %rax
movq -0xb0(%rbp), %rcx
movq -0xa8(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x678(%rbp)
leaq -0x678(%rbp), %rdi
callq 0x17f60
movapd %xmm0, -0x670(%rbp)
movq -0x550(%rbp), %rcx
movq -0x600(%rbp), %rax
addq $0x0, %rax
movq %rcx, -0x3a8(%rbp)
movq $0x0, -0x3b0(%rbp)
movq %rax, -0x3b8(%rbp)
movq -0x3a8(%rbp), %rdx
movq -0x3b0(%rbp), %rcx
movq -0x3b8(%rbp), %rax
movq %rdx, -0x388(%rbp)
movq %rcx, -0x390(%rbp)
movq %rax, -0x398(%rbp)
movq -0x388(%rbp), %rsi
movq (%rsi), %rax
movq -0x390(%rbp), %rcx
movq -0x398(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x3a0(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x3a0(%rbp), %rax
movq %rax, -0x680(%rbp)
movq -0x550(%rbp), %rcx
movq -0x600(%rbp), %rax
addq -0x5e8(%rbp), %rax
movq %rcx, -0x3e0(%rbp)
movq $0x0, -0x3e8(%rbp)
movq %rax, -0x3f0(%rbp)
movq -0x3e0(%rbp), %rdx
movq -0x3e8(%rbp), %rcx
movq -0x3f0(%rbp), %rax
movq %rdx, -0x3c0(%rbp)
movq %rcx, -0x3c8(%rbp)
movq %rax, -0x3d0(%rbp)
movq -0x3c0(%rbp), %rsi
movq (%rsi), %rax
movq -0x3c8(%rbp), %rcx
movq -0x3d0(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x3d8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x3d8(%rbp), %rax
movq %rax, -0x688(%rbp)
movq -0x550(%rbp), %rcx
movq -0x600(%rbp), %rax
addq $0x2, %rax
movq %rcx, -0x418(%rbp)
movq $0x0, -0x420(%rbp)
movq %rax, -0x428(%rbp)
movq -0x418(%rbp), %rdx
movq -0x420(%rbp), %rcx
movq -0x428(%rbp), %rax
movq %rdx, -0x3f8(%rbp)
movq %rcx, -0x400(%rbp)
movq %rax, -0x408(%rbp)
movq -0x3f8(%rbp), %rsi
movq (%rsi), %rax
movq -0x400(%rbp), %rcx
movq -0x408(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x410(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x410(%rbp), %rax
movq %rax, -0x690(%rbp)
movq -0x550(%rbp), %rcx
movq -0x600(%rbp), %rax
addq -0x5f0(%rbp), %rax
movq %rcx, -0x450(%rbp)
movq $0x0, -0x458(%rbp)
movq %rax, -0x460(%rbp)
movq -0x450(%rbp), %rdx
movq -0x458(%rbp), %rcx
movq -0x460(%rbp), %rax
movq %rdx, -0x430(%rbp)
movq %rcx, -0x438(%rbp)
movq %rax, -0x440(%rbp)
movq -0x430(%rbp), %rsi
movq (%rsi), %rax
movq -0x438(%rbp), %rcx
movq -0x440(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x448(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x448(%rbp), %rax
movq %rax, -0x698(%rbp)
movq $0x0, -0x6a0(%rbp)
movq -0x6a0(%rbp), %rax
cmpq -0x5b0(%rbp), %rax
jge 0x64deb
movq -0x6a0(%rbp), %rax
leaq -0x680(%rbp), %rcx
movq %rcx, -0x4a0(%rbp)
movq %rax, -0x4a8(%rbp)
movq -0x4a0(%rbp), %rax
movq (%rax), %rax
movq -0x4a8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x6a8(%rbp)
leaq -0x610(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0x6b0(%rbp)
movq -0x560(%rbp), %rcx
movq -0x6a0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
leaq -0x571(%rbp), %rdi
leaq -0x6a8(%rbp), %rsi
leaq -0x6b0(%rbp), %rdx
callq 0x667d0
movq -0x560(%rbp), %rax
movq -0x6a0(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x6a0(%rbp), %rax
leaq -0x688(%rbp), %rcx
movq %rcx, -0x4b0(%rbp)
movq %rax, -0x4b8(%rbp)
movq -0x4b0(%rbp), %rax
movq (%rax), %rax
movq -0x4b8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x6b8(%rbp)
leaq -0x630(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0x6c0(%rbp)
movq -0x560(%rbp), %rcx
movq -0x6a0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
leaq -0x571(%rbp), %rdi
leaq -0x6b8(%rbp), %rsi
leaq -0x6c0(%rbp), %rdx
callq 0x667d0
movq -0x560(%rbp), %rax
movq -0x6a0(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x6a0(%rbp), %rax
leaq -0x690(%rbp), %rcx
movq %rcx, -0x4c0(%rbp)
movq %rax, -0x4c8(%rbp)
movq -0x4c0(%rbp), %rax
movq (%rax), %rax
movq -0x4c8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x6c8(%rbp)
leaq -0x650(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0x6d0(%rbp)
movq -0x560(%rbp), %rcx
movq -0x6a0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
leaq -0x571(%rbp), %rdi
leaq -0x6c8(%rbp), %rsi
leaq -0x6d0(%rbp), %rdx
callq 0x667d0
movq -0x560(%rbp), %rax
movq -0x6a0(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x6a0(%rbp), %rax
leaq -0x698(%rbp), %rcx
movq %rcx, -0x4d0(%rbp)
movq %rax, -0x4d8(%rbp)
movq -0x4d0(%rbp), %rax
movq (%rax), %rax
movq -0x4d8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x6d8(%rbp)
leaq -0x670(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0x6e0(%rbp)
movq -0x560(%rbp), %rcx
movq -0x6a0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
leaq -0x571(%rbp), %rdi
leaq -0x6d8(%rbp), %rsi
leaq -0x6e0(%rbp), %rdx
callq 0x667d0
movq -0x560(%rbp), %rax
movq -0x6a0(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x6a0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x6a0(%rbp)
jmp 0x64b80
movq -0x5b8(%rbp), %rax
cmpq -0x5b0(%rbp), %rax
jle 0x65f52
movq -0x5d0(%rbp), %rax
movq %rax, -0xc68(%rbp)
testq %rax, %rax
je 0x64e3d
jmp 0x64e14
movq -0xc68(%rbp), %rax
subq $0x1, %rax
je 0x650fc
jmp 0x64e27
movq -0xc68(%rbp), %rax
subq $0x2, %rax
je 0x653bb
jmp 0x65c94
movq -0x5b0(%rbp), %rax
movq %rax, -0x6e8(%rbp)
movq -0x6e8(%rbp), %rax
cmpq -0x5b8(%rbp), %rax
jge 0x650f7
movq -0x560(%rbp), %rax
movq -0x6e8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xc70(%rbp)
movq -0x560(%rbp), %rdi
movq -0x6e8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x16f50
movapd %xmm0, -0x710(%rbp)
movq -0x6e8(%rbp), %rax
leaq -0x680(%rbp), %rcx
movq %rcx, -0x1c8(%rbp)
movq %rax, -0x1d0(%rbp)
movq -0x1c8(%rbp), %rax
movq (%rax), %rax
movq -0x1d0(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x1c0(%rbp)
movq -0x1c0(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x750(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x750(%rbp), %rsi
leaq -0x610(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x740(%rbp)
movq -0x6e8(%rbp), %rax
leaq -0x688(%rbp), %rcx
movq %rcx, -0x1e0(%rbp)
movq %rax, -0x1e8(%rbp)
movq -0x1e0(%rbp), %rax
movq (%rax), %rax
movq -0x1e8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x1d8(%rbp)
movq -0x1d8(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x770(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x770(%rbp), %rsi
leaq -0x630(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x760(%rbp)
leaq -0x740(%rbp), %rdi
leaq -0x760(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0x730(%rbp)
movq -0x6e8(%rbp), %rax
leaq -0x690(%rbp), %rcx
movq %rcx, -0x1f8(%rbp)
movq %rax, -0x200(%rbp)
movq -0x1f8(%rbp), %rax
movq (%rax), %rax
movq -0x200(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x1f0(%rbp)
movq -0x1f0(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x7a0(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x7a0(%rbp), %rsi
leaq -0x650(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x790(%rbp)
movq -0x6e8(%rbp), %rax
leaq -0x698(%rbp), %rcx
movq %rcx, -0x210(%rbp)
movq %rax, -0x218(%rbp)
movq -0x210(%rbp), %rax
movq (%rax), %rax
movq -0x218(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x7c0(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x7c0(%rbp), %rsi
leaq -0x670(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x7b0(%rbp)
leaq -0x790(%rbp), %rdi
leaq -0x7b0(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0x780(%rbp)
leaq -0x730(%rbp), %rdi
leaq -0x780(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0x720(%rbp)
leaq -0x710(%rbp), %rdi
leaq -0x720(%rbp), %rsi
callq 0x17e30
movq -0xc70(%rbp), %rdi
movapd %xmm0, -0x700(%rbp)
leaq -0x700(%rbp), %rsi
callq 0x16f20
movq -0x6e8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x6e8(%rbp)
jmp 0x64e4b
jmp 0x65f50
movq -0x5b0(%rbp), %rax
movq %rax, -0x7c8(%rbp)
movq -0x7c8(%rbp), %rax
cmpq -0x5b8(%rbp), %rax
jge 0x653b6
movq -0x560(%rbp), %rax
movq -0x7c8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xc78(%rbp)
movq -0x560(%rbp), %rdi
movq -0x7c8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x16f50
movapd %xmm0, -0x7f0(%rbp)
movq -0x7c8(%rbp), %rax
leaq -0x680(%rbp), %rcx
movq %rcx, -0x228(%rbp)
movq %rax, -0x230(%rbp)
movq -0x228(%rbp), %rax
movq (%rax), %rax
movq -0x230(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x220(%rbp)
movq -0x220(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x830(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x830(%rbp), %rsi
leaq -0x610(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x820(%rbp)
movq -0x7c8(%rbp), %rax
leaq -0x688(%rbp), %rcx
movq %rcx, -0xd8(%rbp)
movq %rax, -0xe0(%rbp)
movq -0xd8(%rbp), %rax
movq (%rax), %rax
movq -0xe0(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0x850(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x850(%rbp), %rsi
leaq -0x630(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x840(%rbp)
leaq -0x820(%rbp), %rdi
leaq -0x840(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0x810(%rbp)
movq -0x7c8(%rbp), %rax
leaq -0x690(%rbp), %rcx
movq %rcx, -0x240(%rbp)
movq %rax, -0x248(%rbp)
movq -0x240(%rbp), %rax
movq (%rax), %rax
movq -0x248(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x880(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x880(%rbp), %rsi
leaq -0x650(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x870(%rbp)
movq -0x7c8(%rbp), %rax
leaq -0x698(%rbp), %rcx
movq %rcx, -0xf0(%rbp)
movq %rax, -0xf8(%rbp)
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq -0xf8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0x8a0(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x8a0(%rbp), %rsi
leaq -0x670(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x890(%rbp)
leaq -0x870(%rbp), %rdi
leaq -0x890(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0x860(%rbp)
leaq -0x810(%rbp), %rdi
leaq -0x860(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0x800(%rbp)
leaq -0x7f0(%rbp), %rdi
leaq -0x800(%rbp), %rsi
callq 0x17e30
movq -0xc78(%rbp), %rdi
movapd %xmm0, -0x7e0(%rbp)
leaq -0x7e0(%rbp), %rsi
callq 0x16f20
movq -0x7c8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x7c8(%rbp)
jmp 0x6510a
jmp 0x65f50
movq -0x5b0(%rbp), %rax
movq %rax, -0x8a8(%rbp)
movq -0x5b0(%rbp), %rax
subq $0x1, %rax
leaq -0x688(%rbp), %rcx
movq %rcx, -0x258(%rbp)
movq %rax, -0x260(%rbp)
movq -0x258(%rbp), %rax
movq (%rax), %rax
movq -0x260(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x250(%rbp)
movq -0x250(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x8d0(%rbp)
movq -0x5b0(%rbp), %rax
subq $0x2, %rax
leaq -0x690(%rbp), %rcx
movq %rcx, -0x270(%rbp)
movq %rax, -0x278(%rbp)
movq -0x270(%rbp), %rax
movq (%rax), %rax
movq -0x278(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x268(%rbp)
movq -0x268(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x8e0(%rbp)
movq -0x5b0(%rbp), %rax
subq $0x3, %rax
leaq -0x698(%rbp), %rcx
movq %rcx, -0x288(%rbp)
movq %rax, -0x290(%rbp)
movq -0x288(%rbp), %rax
movq (%rax), %rax
movq -0x290(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x280(%rbp)
movq -0x280(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x8f0(%rbp)
movq -0x8a8(%rbp), %rax
cmpq -0x5c0(%rbp), %rax
jge 0x659e1
movq -0x8a8(%rbp), %rax
subq $0x1, %rax
addq $0x2, %rax
leaq -0x688(%rbp), %rcx
movq %rcx, -0x2a0(%rbp)
movq %rax, -0x2a8(%rbp)
movq -0x2a0(%rbp), %rax
movq (%rax), %rax
movq -0x2a8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x298(%rbp)
movq -0x298(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x910(%rbp)
leaq -0x8d0(%rbp), %rdi
leaq -0x910(%rbp), %rsi
callq 0x31060
movq -0x8a8(%rbp), %rax
subq $0x2, %rax
addq $0x2, %rax
leaq -0x690(%rbp), %rcx
movq %rcx, -0x2b8(%rbp)
movq %rax, -0x2c0(%rbp)
movq -0x2b8(%rbp), %rax
movq (%rax), %rax
movq -0x2c0(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x2b0(%rbp)
movq -0x2b0(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x920(%rbp)
leaq -0x8e0(%rbp), %rdi
leaq -0x920(%rbp), %rsi
callq 0x31090
movq -0x8a8(%rbp), %rax
subq $0x3, %rax
addq $0x2, %rax
leaq -0x698(%rbp), %rcx
movq %rcx, -0x2d0(%rbp)
movq %rax, -0x2d8(%rbp)
movq -0x2d0(%rbp), %rax
movq (%rax), %rax
movq -0x2d8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x2c8(%rbp)
movq -0x2c8(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x930(%rbp)
leaq -0x8f0(%rbp), %rdi
leaq -0x930(%rbp), %rsi
callq 0x310c0
movq -0x8a8(%rbp), %rax
leaq -0x680(%rbp), %rcx
movq %rcx, -0x2e8(%rbp)
movq %rax, -0x2f0(%rbp)
movq -0x2e8(%rbp), %rax
movq (%rax), %rax
movq -0x2f0(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x2e0(%rbp)
movq -0x2e0(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x8c0(%rbp)
movq -0x8a8(%rbp), %rax
addq $0x2, %rax
leaq -0x680(%rbp), %rcx
movq %rcx, -0x300(%rbp)
movq %rax, -0x308(%rbp)
movq -0x300(%rbp), %rax
movq (%rax), %rax
movq -0x308(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x2f8(%rbp)
movq -0x2f8(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x900(%rbp)
movq -0x560(%rbp), %rdi
movq -0x8a8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x16f50
movapd %xmm0, -0x960(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x8c0(%rbp), %rsi
leaq -0x610(%rbp), %rdx
leaq -0x960(%rbp), %rcx
callq 0x31030
movapd %xmm0, -0x940(%rbp)
movq -0x560(%rbp), %rdi
movq -0x8a8(%rbp), %rax
addq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x16f50
movapd %xmm0, -0x970(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x900(%rbp), %rsi
leaq -0x610(%rbp), %rdx
leaq -0x970(%rbp), %rcx
callq 0x31030
movapd %xmm0, -0x950(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x8d0(%rbp), %rsi
leaq -0x630(%rbp), %rdx
leaq -0x940(%rbp), %rcx
callq 0x31030
movapd %xmm0, -0x940(%rbp)
movq -0x8a8(%rbp), %rax
subq $0x1, %rax
addq $0x4, %rax
leaq -0x688(%rbp), %rcx
movq %rcx, -0x318(%rbp)
movq %rax, -0x320(%rbp)
movq -0x318(%rbp), %rax
movq (%rax), %rax
movq -0x320(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x310(%rbp)
movq -0x310(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x8d0(%rbp)
leaq -0x910(%rbp), %rdi
leaq -0x8d0(%rbp), %rsi
callq 0x31060
leaq -0x572(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
leaq -0x650(%rbp), %rdx
leaq -0x940(%rbp), %rcx
callq 0x31030
movapd %xmm0, -0x940(%rbp)
movq -0x8a8(%rbp), %rax
subq $0x2, %rax
addq $0x4, %rax
leaq -0x690(%rbp), %rcx
movq %rcx, -0x330(%rbp)
movq %rax, -0x338(%rbp)
movq -0x330(%rbp), %rax
movq (%rax), %rax
movq -0x338(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x328(%rbp)
movq -0x328(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x8e0(%rbp)
leaq -0x920(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x31090
leaq -0x572(%rbp), %rdi
leaq -0x8f0(%rbp), %rsi
leaq -0x670(%rbp), %rdx
leaq -0x940(%rbp), %rcx
callq 0x31030
movapd %xmm0, -0x940(%rbp)
movq -0x560(%rbp), %rdi
movq -0x8a8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x940(%rbp), %rsi
callq 0x16f20
movq -0x8a8(%rbp), %rax
subq $0x3, %rax
addq $0x4, %rax
leaq -0x698(%rbp), %rcx
movq %rcx, -0x348(%rbp)
movq %rax, -0x350(%rbp)
movq -0x348(%rbp), %rax
movq (%rax), %rax
movq -0x350(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x340(%rbp)
movq -0x340(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x8f0(%rbp)
leaq -0x930(%rbp), %rdi
leaq -0x8f0(%rbp), %rsi
callq 0x310c0
leaq -0x572(%rbp), %rdi
leaq -0x910(%rbp), %rsi
leaq -0x630(%rbp), %rdx
leaq -0x950(%rbp), %rcx
callq 0x31030
movapd %xmm0, -0x950(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x920(%rbp), %rsi
leaq -0x650(%rbp), %rdx
leaq -0x950(%rbp), %rcx
callq 0x31030
movapd %xmm0, -0x950(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x930(%rbp), %rsi
leaq -0x670(%rbp), %rdx
leaq -0x950(%rbp), %rcx
callq 0x31030
movapd %xmm0, -0x950(%rbp)
movq -0x560(%rbp), %rdi
movq -0x8a8(%rbp), %rax
addq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x950(%rbp), %rsi
callq 0x16f20
movq -0x8a8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8a8(%rbp)
jmp 0x654c2
jmp 0x659e3
movq -0x8a8(%rbp), %rax
cmpq -0x5b8(%rbp), %rax
jge 0x65c8f
movq -0x560(%rbp), %rax
movq -0x8a8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xc80(%rbp)
movq -0x560(%rbp), %rdi
movq -0x8a8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x16f50
movapd %xmm0, -0x990(%rbp)
movq -0x8a8(%rbp), %rax
leaq -0x680(%rbp), %rcx
movq %rcx, -0x360(%rbp)
movq %rax, -0x368(%rbp)
movq -0x360(%rbp), %rax
movq (%rax), %rax
movq -0x368(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x358(%rbp)
movq -0x358(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0x9d0(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x9d0(%rbp), %rsi
leaq -0x610(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x9c0(%rbp)
movq -0x8a8(%rbp), %rax
leaq -0x688(%rbp), %rcx
movq %rcx, -0x108(%rbp)
movq %rax, -0x110(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq -0x110(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0x9f0(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0x9f0(%rbp), %rsi
leaq -0x630(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0x9e0(%rbp)
leaq -0x9c0(%rbp), %rdi
leaq -0x9e0(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0x9b0(%rbp)
movq -0x8a8(%rbp), %rax
leaq -0x690(%rbp), %rcx
movq %rcx, -0x120(%rbp)
movq %rax, -0x128(%rbp)
movq -0x120(%rbp), %rax
movq (%rax), %rax
movq -0x128(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0xa20(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0xa20(%rbp), %rsi
leaq -0x650(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0xa10(%rbp)
movq -0x8a8(%rbp), %rax
leaq -0x698(%rbp), %rcx
movq %rcx, -0x138(%rbp)
movq %rax, -0x140(%rbp)
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq -0x140(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0xa40(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0xa40(%rbp), %rsi
leaq -0x670(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0xa30(%rbp)
leaq -0xa10(%rbp), %rdi
leaq -0xa30(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0xa00(%rbp)
leaq -0x9b0(%rbp), %rdi
leaq -0xa00(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0x9a0(%rbp)
leaq -0x990(%rbp), %rdi
leaq -0x9a0(%rbp), %rsi
callq 0x17e30
movq -0xc80(%rbp), %rdi
movapd %xmm0, -0x980(%rbp)
leaq -0x980(%rbp), %rsi
callq 0x16f20
movq -0x8a8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8a8(%rbp)
jmp 0x659e3
jmp 0x65f50
movq -0x5b0(%rbp), %rax
movq %rax, -0xa48(%rbp)
movq -0xa48(%rbp), %rax
cmpq -0x5b8(%rbp), %rax
jge 0x65f4e
movq -0x560(%rbp), %rax
movq -0xa48(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xc88(%rbp)
movq -0x560(%rbp), %rdi
movq -0xa48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x16f50
movapd %xmm0, -0xa70(%rbp)
movq -0xa48(%rbp), %rax
leaq -0x680(%rbp), %rcx
movq %rcx, -0x150(%rbp)
movq %rax, -0x158(%rbp)
movq -0x150(%rbp), %rax
movq (%rax), %rax
movq -0x158(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0xab0(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0xab0(%rbp), %rsi
leaq -0x610(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0xaa0(%rbp)
movq -0xa48(%rbp), %rax
leaq -0x688(%rbp), %rcx
movq %rcx, -0x168(%rbp)
movq %rax, -0x170(%rbp)
movq -0x168(%rbp), %rax
movq (%rax), %rax
movq -0x170(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x160(%rbp)
movq -0x160(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0xad0(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0xad0(%rbp), %rsi
leaq -0x630(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0xac0(%rbp)
leaq -0xaa0(%rbp), %rdi
leaq -0xac0(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0xa90(%rbp)
movq -0xa48(%rbp), %rax
leaq -0x690(%rbp), %rcx
movq %rcx, -0x180(%rbp)
movq %rax, -0x188(%rbp)
movq -0x180(%rbp), %rax
movq (%rax), %rax
movq -0x188(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x178(%rbp)
movq -0x178(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0xb00(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0xb00(%rbp), %rsi
leaq -0x650(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0xaf0(%rbp)
movq -0xa48(%rbp), %rax
leaq -0x698(%rbp), %rcx
movq %rcx, -0x198(%rbp)
movq %rax, -0x1a0(%rbp)
movq -0x198(%rbp), %rax
movq (%rax), %rax
movq -0x1a0(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x190(%rbp)
movq -0x190(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0xb20(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0xb20(%rbp), %rsi
leaq -0x670(%rbp), %rdx
callq 0x2a7c0
movapd %xmm0, -0xb10(%rbp)
leaq -0xaf0(%rbp), %rdi
leaq -0xb10(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0xae0(%rbp)
leaq -0xa90(%rbp), %rdi
leaq -0xae0(%rbp), %rsi
callq 0x17e30
movapd %xmm0, -0xa80(%rbp)
leaq -0xa70(%rbp), %rdi
leaq -0xa80(%rbp), %rsi
callq 0x17e30
movq -0xc88(%rbp), %rdi
movapd %xmm0, -0xa60(%rbp)
leaq -0xa60(%rbp), %rsi
callq 0x16f20
movq -0xa48(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xa48(%rbp)
jmp 0x65ca2
jmp 0x65f50
jmp 0x65f52
movq -0x5b8(%rbp), %rax
movq %rax, -0xb28(%rbp)
movq -0xb28(%rbp), %rax
cmpq -0x5a0(%rbp), %rax
jge 0x661cb
movq -0xb28(%rbp), %rax
leaq -0x680(%rbp), %rcx
movq %rcx, -0x4e0(%rbp)
movq %rax, -0x4e8(%rbp)
movq -0x4e0(%rbp), %rax
movq (%rax), %rax
movq -0x4e8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0xb30(%rbp)
leaq -0x610(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0xb38(%rbp)
movq -0x560(%rbp), %rcx
movq -0xb28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
leaq -0x571(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
leaq -0xb38(%rbp), %rdx
callq 0x667d0
movq -0x560(%rbp), %rax
movq -0xb28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0xb28(%rbp), %rax
leaq -0x688(%rbp), %rcx
movq %rcx, -0x4f0(%rbp)
movq %rax, -0x4f8(%rbp)
movq -0x4f0(%rbp), %rax
movq (%rax), %rax
movq -0x4f8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0xb40(%rbp)
leaq -0x630(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0xb48(%rbp)
movq -0x560(%rbp), %rcx
movq -0xb28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
leaq -0x571(%rbp), %rdi
leaq -0xb40(%rbp), %rsi
leaq -0xb48(%rbp), %rdx
callq 0x667d0
movq -0x560(%rbp), %rax
movq -0xb28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0xb28(%rbp), %rax
leaq -0x690(%rbp), %rcx
movq %rcx, -0x500(%rbp)
movq %rax, -0x508(%rbp)
movq -0x500(%rbp), %rax
movq (%rax), %rax
movq -0x508(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0xb50(%rbp)
leaq -0x650(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0xb58(%rbp)
movq -0x560(%rbp), %rcx
movq -0xb28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
leaq -0x571(%rbp), %rdi
leaq -0xb50(%rbp), %rsi
leaq -0xb58(%rbp), %rdx
callq 0x667d0
movq -0x560(%rbp), %rax
movq -0xb28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0xb28(%rbp), %rax
leaq -0x698(%rbp), %rcx
movq %rcx, -0x510(%rbp)
movq %rax, -0x518(%rbp)
movq -0x510(%rbp), %rax
movq (%rax), %rax
movq -0x518(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0xb60(%rbp)
leaq -0x670(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0xb68(%rbp)
movq -0x560(%rbp), %rcx
movq -0xb28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
leaq -0x571(%rbp), %rdi
leaq -0xb60(%rbp), %rsi
leaq -0xb68(%rbp), %rdx
callq 0x667d0
movq -0x560(%rbp), %rax
movq -0xb28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0xb28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb28(%rbp)
jmp 0x65f60
jmp 0x661cd
movq -0x600(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x600(%rbp)
jmp 0x6471d
movq -0x548(%rbp), %rax
movq %rax, -0xb70(%rbp)
movq -0x5f8(%rbp), %rax
movq %rax, -0xb78(%rbp)
movq -0xb78(%rbp), %rax
movq %rax, -0xb80(%rbp)
movq -0xb80(%rbp), %rax
cmpq -0xb70(%rbp), %rax
jge 0x666e1
movsd -0x570(%rbp), %xmm0
movq -0x558(%rbp), %rcx
movq -0xb80(%rbp), %rax
movq %rcx, -0xb8(%rbp)
movq %rax, -0xc0(%rbp)
movq $0x0, -0xc8(%rbp)
movq -0xb8(%rbp), %rsi
movq (%rsi), %rax
movq -0xc8(%rbp), %rcx
movq -0xc0(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0xb98(%rbp)
leaq -0xb98(%rbp), %rdi
callq 0x17f60
movapd %xmm0, -0xb90(%rbp)
movq -0x550(%rbp), %rcx
movq -0xb80(%rbp), %rax
movq %rcx, -0x488(%rbp)
movq $0x0, -0x490(%rbp)
movq %rax, -0x498(%rbp)
movq -0x488(%rbp), %rdx
movq -0x490(%rbp), %rcx
movq -0x498(%rbp), %rax
movq %rdx, -0x468(%rbp)
movq %rcx, -0x470(%rbp)
movq %rax, -0x478(%rbp)
movq -0x468(%rbp), %rsi
movq (%rsi), %rax
movq -0x470(%rbp), %rcx
movq -0x478(%rbp), %rdx
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
leaq -0x480(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x480(%rbp), %rax
movq %rax, -0xba0(%rbp)
movq $0x0, -0xba8(%rbp)
movq -0xba8(%rbp), %rax
cmpq -0x5b0(%rbp), %rax
jge 0x663e8
movq -0xba8(%rbp), %rax
leaq -0xba0(%rbp), %rcx
movq %rcx, -0x520(%rbp)
movq %rax, -0x528(%rbp)
movq -0x520(%rbp), %rax
movq (%rax), %rax
movq -0x528(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0xbb0(%rbp)
leaq -0xb90(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0xbb8(%rbp)
leaq -0x571(%rbp), %rdi
leaq -0xbb0(%rbp), %rsi
leaq -0xbb8(%rbp), %rdx
callq 0x2a870
movq -0x560(%rbp), %rax
movq -0xba8(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0xba8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xba8(%rbp)
jmp 0x6633d
movq -0x5b0(%rbp), %rsi
leaq -0xba0(%rbp), %rdi
callq 0x310f0
testb $0x1, %al
jne 0x66404
jmp 0x6650b
movq -0x5b0(%rbp), %rax
movq %rax, -0xbc0(%rbp)
movq -0xbc0(%rbp), %rax
cmpq -0x5b8(%rbp), %rax
jge 0x66506
movq -0x560(%rbp), %rax
movq -0xbc0(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xc90(%rbp)
movq -0xbc0(%rbp), %rax
leaq -0xba0(%rbp), %rcx
movq %rcx, -0x378(%rbp)
movq %rax, -0x380(%rbp)
movq -0x378(%rbp), %rax
movq (%rax), %rax
movq -0x380(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x370(%rbp)
movq -0x370(%rbp), %rdi
callq 0x16f50
movapd %xmm0, -0xbe0(%rbp)
movq -0x560(%rbp), %rdi
movq -0xbc0(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x16f50
movapd %xmm0, -0xbf0(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0xbe0(%rbp), %rsi
leaq -0xb90(%rbp), %rdx
leaq -0xbf0(%rbp), %rcx
callq 0x31030
movq -0xc90(%rbp), %rdi
movapd %xmm0, -0xbd0(%rbp)
leaq -0xbd0(%rbp), %rsi
callq 0x16f20
movq -0xbc0(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xbc0(%rbp)
jmp 0x66412
jmp 0x6660f
movq -0x5b0(%rbp), %rax
movq %rax, -0xbf8(%rbp)
movq -0xbf8(%rbp), %rax
cmpq -0x5b8(%rbp), %rax
jge 0x6660d
movq -0x560(%rbp), %rax
movq -0xbf8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xc98(%rbp)
movq -0xbf8(%rbp), %rax
leaq -0xba0(%rbp), %rcx
movq %rcx, -0x1b0(%rbp)
movq %rax, -0x1b8(%rbp)
movq -0x1b0(%rbp), %rax
movq (%rax), %rax
movq -0x1b8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rdi
callq 0x16f70
movapd %xmm0, -0xc20(%rbp)
movq -0x560(%rbp), %rdi
movq -0xbf8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x16f50
movapd %xmm0, -0xc30(%rbp)
leaq -0x572(%rbp), %rdi
leaq -0xc20(%rbp), %rsi
leaq -0xb90(%rbp), %rdx
leaq -0xc30(%rbp), %rcx
callq 0x31030
movq -0xc98(%rbp), %rdi
movapd %xmm0, -0xc10(%rbp)
leaq -0xc10(%rbp), %rsi
callq 0x16f20
movq -0xbf8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xbf8(%rbp)
jmp 0x66519
jmp 0x6660f
movq -0x5b8(%rbp), %rax
movq %rax, -0xc38(%rbp)
movq -0xc38(%rbp), %rax
cmpq -0x5a0(%rbp), %rax
jge 0x666c8
movq -0xc38(%rbp), %rax
leaq -0xba0(%rbp), %rcx
movq %rcx, -0x530(%rbp)
movq %rax, -0x538(%rbp)
movq -0x530(%rbp), %rax
movq (%rax), %rax
movq -0x538(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0xc40(%rbp)
leaq -0xb90(%rbp), %rdi
callq 0x19110
movsd %xmm0, -0xc48(%rbp)
leaq -0x571(%rbp), %rdi
leaq -0xc40(%rbp), %rsi
leaq -0xc48(%rbp), %rdx
callq 0x2a870
movq -0x560(%rbp), %rax
movq -0xc38(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0xc38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc38(%rbp)
jmp 0x6661d
jmp 0x666ca
movq -0xb80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb80(%rbp)
jmp 0x6620e
cmpq $0x0, -0x5e0(%rbp)
je 0x66711
movq $0x0, -0xb78(%rbp)
movq -0x5e0(%rbp), %rax
movq %rax, -0xb70(%rbp)
movq $0x0, -0x5e0(%rbp)
jmp 0x66713
jmp 0x66721
jmp 0x66715
movb $0x1, %al
testb $0x1, %al
jne 0x66200
jmp 0x66721
addq $0xca0, %rsp            # imm = 0xCA0
popq %rbp
retq
nopw (%rax,%rax)