// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::lhs_process_one_packet<4, 2l, 1l, double, double, double, double vector[2], double vector[2], double vector[2], double vector[2], Eigen::internal::gebp_traits<double, double, false, false, 1, 0>, Eigen::internal::BlasLinearMapper<double, long, 0, 1>, Eigen::internal::blas_data_mapper<double, long, 0, 0, 1>>::operator()(Eigen::internal::blas_data_mapper<double, long, 0, 0, 1> const&, double const*, double const*, double, long, long, long, long, long, long, int, long, long, long, long, long)
EIGEN_STRONG_INLINE void operator()(
    const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB, ResScalar alpha,
    Index peelStart, Index peelEnd, Index strideA, Index strideB, Index offsetA, Index offsetB,
    int prefetch_res_offset, Index peeled_kc, Index pk, Index cols, Index depth, Index packet_cols4)
  {
    GEBPTraits traits;

    // loops on each largest micro horizontal panel of lhs
    // (LhsProgress x depth)
    for(Index i=peelStart; i<peelEnd; i+=LhsProgress)
    {
      // loops on each largest micro vertical panel of rhs (depth * nr)
      for(Index j2=0; j2<packet_cols4; j2+=nr)
      {
        // We select a LhsProgress x nr micro block of res
        // which is entirely stored into 1 x nr registers.

        const LhsScalar* blA = &blockA[i*strideA+offsetA*(LhsProgress)];
        prefetch(&blA[0]);

        // gets res block as register
        AccPacket C0, C1, C2, C3;
        traits.initAcc(C0);
        traits.initAcc(C1);
        traits.initAcc(C2);
        traits.initAcc(C3);
        // To improve instruction pipelining, let's double the accumulation registers:
        //  even k will accumulate in C*, while odd k will accumulate in D*.
        // This trick is crutial to get good performance with FMA, otherwise it is 
        // actually faster to perform separated MUL+ADD because of a naturally
        // better instruction-level parallelism.
        AccPacket D0, D1, D2, D3;
        traits.initAcc(D0);
        traits.initAcc(D1);
        traits.initAcc(D2);
        traits.initAcc(D3);

        LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
        LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
        LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
        LinearMapper r3 = res.getLinearMapper(i, j2 + 3);

        r0.prefetch(prefetch_res_offset);
        r1.prefetch(prefetch_res_offset);
        r2.prefetch(prefetch_res_offset);
        r3.prefetch(prefetch_res_offset);

        // performs "inner" products
        const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
        prefetch(&blB[0]);
        LhsPacket A0, A1;

        for(Index k=0; k<peeled_kc; k+=pk)
        {
          EIGEN_ASM_COMMENT("begin gebp micro kernel 1/half/quarterX4");
          RhsPacketx4 rhs_panel;
          RhsPacket T0;

          internal::prefetch(blB+(48+0));
          peeled_kc_onestep(0, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          peeled_kc_onestep(1, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
          peeled_kc_onestep(2, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          peeled_kc_onestep(3, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
          internal::prefetch(blB+(48+16));
          peeled_kc_onestep(4, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          peeled_kc_onestep(5, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
          peeled_kc_onestep(6, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          peeled_kc_onestep(7, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);

          blB += pk*4*RhsProgress;
          blA += pk*LhsProgress;

          EIGEN_ASM_COMMENT("end gebp micro kernel 1/half/quarterX4");
        }
        C0 = padd(C0,D0);
        C1 = padd(C1,D1);
        C2 = padd(C2,D2);
        C3 = padd(C3,D3);

        // process remaining peeled loop
        for(Index k=peeled_kc; k<depth; k++)
        {
          RhsPacketx4 rhs_panel;
          RhsPacket T0;
          peeled_kc_onestep(0, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
          blB += 4*RhsProgress;
          blA += LhsProgress;
        }

        ResPacket R0, R1;
        ResPacket alphav = pset1<ResPacket>(alpha);

        R0 = r0.template loadPacket<ResPacket>(0);
        R1 = r1.template loadPacket<ResPacket>(0);
        traits.acc(C0, alphav, R0);
        traits.acc(C1,  alphav, R1);
        r0.storePacket(0, R0);
        r1.storePacket(0, R1);

        R0 = r2.template loadPacket<ResPacket>(0);
        R1 = r3.template loadPacket<ResPacket>(0);
        traits.acc(C2,  alphav, R0);
        traits.acc(C3,  alphav, R1);
        r2.storePacket(0, R0);
        r3.storePacket(0, R1);
      }

      // Deal with remaining columns of the rhs
      for(Index j2=packet_cols4; j2<cols; j2++)
      {
        // One column at a time
        const LhsScalar* blA = &blockA[i*strideA+offsetA*(LhsProgress)];
        prefetch(&blA[0]);

        // gets res block as register
        AccPacket C0;
        traits.initAcc(C0);

        LinearMapper r0 = res.getLinearMapper(i, j2);

        // performs "inner" products
        const RhsScalar* blB = &blockB[j2*strideB+offsetB];
        LhsPacket A0;

        for(Index k= 0; k<peeled_kc; k+=pk)
        {
          EIGEN_ASM_COMMENT("begin gebp micro kernel 1/half/quarterX1");
          RhsPacket B_0;

#define EIGEN_GEBGP_ONESTEP(K)                                          \
	      do {                                                      \
		EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1/half/quarterX1"); \
		EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
    /* FIXME: why unaligned???? */ \
		traits.loadLhsUnaligned(&blA[(0+1*K)*LhsProgress], A0); \
		traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);		\
		traits.madd(A0, B_0, C0, B_0, fix<0>);				\
		EIGEN_ASM_COMMENT("end step of gebp micro kernel 1/half/quarterX1"); \
	      } while(false);

          EIGEN_GEBGP_ONESTEP(0);
          EIGEN_GEBGP_ONESTEP(1);
          EIGEN_GEBGP_ONESTEP(2);
          EIGEN_GEBGP_ONESTEP(3);
          EIGEN_GEBGP_ONESTEP(4);
          EIGEN_GEBGP_ONESTEP(5);
          EIGEN_GEBGP_ONESTEP(6);
          EIGEN_GEBGP_ONESTEP(7);

          blB += pk*RhsProgress;
          blA += pk*LhsProgress;

          EIGEN_ASM_COMMENT("end gebp micro kernel 1/half/quarterX1");
        }

        // process remaining peeled loop
        for(Index k=peeled_kc; k<depth; k++)
        {
          RhsPacket B_0;
          EIGEN_GEBGP_ONESTEP(0);
          blB += RhsProgress;
          blA += LhsProgress;
        }
#undef EIGEN_GEBGP_ONESTEP
        ResPacket R0;
        ResPacket alphav = pset1<ResPacket>(alpha);
        R0 = r0.template loadPacket<ResPacket>(0);
        traits.acc(C0, alphav, R0);
        r0.storePacket(0, R0);
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, -0x50(%rsp)
movq %r9, -0x30(%rsp)
movq %r8, -0x78(%rsp)
cmpq %r9, %r8
jge 0x1dd2b
movq %rcx, %rax
movq %rdx, %rdi
movq 0x80(%rsp), %r8
movq 0x78(%rsp), %r9
movq 0x68(%rsp), %r10
movq 0x60(%rsp), %r11
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rbx
movq 0x38(%rsp), %r15
shlq $0x4, %rdx
leaq (%rdi,%rdx), %rsi
movq %rsi, -0x68(%rsp)
movq %rcx, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
movq %rsi, -0x58(%rsp)
movq %r10, %r13
shlq $0x5, %r13
movq %r10, %rbp
shlq $0x4, %rbp
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movq %r15, %rsi
imulq -0x78(%rsp), %rsi
leaq (%rdx,%rsi,8), %r14
leaq (%rax,%rcx,8), %r12
addq %rdi, %r14
movq %r8, %rdx
imulq %rbx, %rdx
shlq $0x3, %rcx
leaq (%rcx,%rdx,8), %rcx
movq %rbx, %rdx
shlq $0x5, %rdx
movq %rdx, -0x18(%rsp)
addq %rax, %rcx
movq %rcx, -0x48(%rsp)
shlq $0x4, %r15
movq %r15, -0x40(%rsp)
movq %r9, %r15
subq %r11, %r15
movslq 0x58(%rsp), %rax
movq %rax, -0x20(%rsp)
leaq (,%rbx,8), %rax
movq %rax, -0x28(%rsp)
leaq (,%r10,8), %rax
movq %r12, -0x38(%rsp)
movq %r15, -0x70(%rsp)
movq %rax, -0x60(%rsp)
cmpq $0x0, 0x80(%rsp)
jle 0x1db4d
movq -0x78(%rsp), %rcx
imulq 0x38(%rsp), %rcx
movq -0x68(%rsp), %rdx
leaq (%rdx,%rcx,8), %r9
movq -0x58(%rsp), %r12
xorl %ecx, %ecx
prefetcht0 (%r9)
movq -0x50(%rsp), %rdx
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
movq %rcx, %r8
orq $0x1, %r8
imulq %rdx, %r8
movq %rcx, %rbx
orq $0x2, %rbx
imulq %rdx, %rbx
movq %rcx, %r15
orq $0x3, %r15
imulq %rdx, %r15
imulq %rcx, %rdx
movq %rcx, %rsi
imulq 0x40(%rsp), %rsi
leaq (%rdi,%rdx,8), %rdx
movq %r9, %rax
movq -0x78(%rsp), %r9
leaq (%rdx,%r9,8), %r10
leaq (%rdi,%r8,8), %rdx
leaq (%rdx,%r9,8), %rdx
leaq (%rdi,%rbx,8), %r8
leaq (%r8,%r9,8), %r8
leaq (%rdi,%r15,8), %rdi
leaq (%rdi,%r9,8), %r15
movq -0x20(%rsp), %rdi
movq %r10, -0x10(%rsp)
prefetcht0 (%r10,%rdi,8)
prefetcht0 (%rdx,%rdi,8)
movq %r8, -0x8(%rsp)
prefetcht0 (%r8,%rdi,8)
prefetcht0 (%r15,%rdi,8)
movq -0x58(%rsp), %rdi
prefetcht0 (%rdi,%rsi,8)
testq %r11, %r11
jle 0x1da5f
xorpd %xmm7, %xmm7
xorl %esi, %esi
xorl %ebx, %ebx
xorl %r8d, %r8d
xorpd %xmm6, %xmm6
xorpd %xmm8, %xmm8
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
xorpd %xmm3, %xmm3
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
movq 0x68(%rsp), %r10
prefetcht0 0x180(%r12,%rbx,2)
movapd (%r14,%rbx), %xmm11
movapd (%r12,%rbx,2), %xmm10
movapd 0x10(%r12,%rbx,2), %xmm9
movapd %xmm10, %xmm12
unpcklpd %xmm10, %xmm12          # xmm12 = xmm12[0],xmm10[0]
mulpd %xmm11, %xmm12
addpd %xmm7, %xmm12
unpckhpd %xmm10, %xmm10          # xmm10 = xmm10[1,1]
mulpd %xmm11, %xmm10
addpd %xmm6, %xmm10
movapd %xmm9, %xmm6
unpcklpd %xmm9, %xmm6            # xmm6 = xmm6[0],xmm9[0]
mulpd %xmm11, %xmm6
addpd %xmm8, %xmm6
unpckhpd %xmm9, %xmm9            # xmm9 = xmm9[1,1]
mulpd %xmm11, %xmm9
addpd %xmm5, %xmm9
movapd 0x10(%r14,%rbx), %xmm11
movapd 0x20(%r12,%rbx,2), %xmm7
movapd 0x30(%r12,%rbx,2), %xmm5
movapd %xmm7, %xmm8
unpcklpd %xmm7, %xmm8            # xmm8 = xmm8[0],xmm7[0]
mulpd %xmm11, %xmm8
addpd %xmm4, %xmm8
unpckhpd %xmm7, %xmm7            # xmm7 = xmm7[1,1]
mulpd %xmm11, %xmm7
addpd %xmm3, %xmm7
movapd %xmm5, %xmm3
unpcklpd %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0]
mulpd %xmm11, %xmm3
addpd %xmm2, %xmm3
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
mulpd %xmm11, %xmm5
addpd %xmm1, %xmm5
movapd 0x20(%r14,%rbx), %xmm2
movapd 0x40(%r12,%rbx,2), %xmm4
movapd 0x50(%r12,%rbx,2), %xmm1
movapd %xmm4, %xmm11
unpcklpd %xmm4, %xmm11           # xmm11 = xmm11[0],xmm4[0]
mulpd %xmm2, %xmm11
addpd %xmm12, %xmm11
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
mulpd %xmm2, %xmm4
addpd %xmm10, %xmm4
movapd %xmm1, %xmm10
unpcklpd %xmm1, %xmm10           # xmm10 = xmm10[0],xmm1[0]
mulpd %xmm2, %xmm10
addpd %xmm6, %xmm10
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
mulpd %xmm2, %xmm1
addpd %xmm9, %xmm1
movapd 0x30(%r14,%rbx), %xmm9
movapd 0x60(%r12,%rbx,2), %xmm6
movapd 0x70(%r12,%rbx,2), %xmm2
movapd %xmm6, %xmm12
unpcklpd %xmm6, %xmm12           # xmm12 = xmm12[0],xmm6[0]
mulpd %xmm9, %xmm12
addpd %xmm8, %xmm12
unpckhpd %xmm6, %xmm6            # xmm6 = xmm6[1,1]
mulpd %xmm9, %xmm6
addpd %xmm7, %xmm6
movapd %xmm2, %xmm7
unpcklpd %xmm2, %xmm7            # xmm7 = xmm7[0],xmm2[0]
mulpd %xmm9, %xmm7
addpd %xmm3, %xmm7
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulpd %xmm9, %xmm2
addpd %xmm5, %xmm2
prefetcht0 0x200(%r12,%rbx,2)
movapd 0x40(%r14,%rbx), %xmm5
movapd 0x80(%r12,%rbx,2), %xmm8
movapd 0x90(%r12,%rbx,2), %xmm3
movapd %xmm8, %xmm13
unpcklpd %xmm8, %xmm13           # xmm13 = xmm13[0],xmm8[0]
mulpd %xmm5, %xmm13
addpd %xmm11, %xmm13
unpckhpd %xmm8, %xmm8            # xmm8 = xmm8[1,1]
mulpd %xmm5, %xmm8
addpd %xmm4, %xmm8
movapd %xmm3, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
mulpd %xmm5, %xmm4
addpd %xmm10, %xmm4
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
mulpd %xmm5, %xmm3
addpd %xmm1, %xmm3
movapd 0x50(%r14,%rbx), %xmm1
movapd 0xa0(%r12,%rbx,2), %xmm10
movapd 0xb0(%r12,%rbx,2), %xmm9
movapd %xmm10, %xmm11
unpcklpd %xmm10, %xmm11          # xmm11 = xmm11[0],xmm10[0]
mulpd %xmm1, %xmm11
addpd %xmm12, %xmm11
unpckhpd %xmm10, %xmm10          # xmm10 = xmm10[1,1]
mulpd %xmm1, %xmm10
addpd %xmm6, %xmm10
movapd %xmm9, %xmm12
unpcklpd %xmm9, %xmm12           # xmm12 = xmm12[0],xmm9[0]
mulpd %xmm1, %xmm12
addpd %xmm7, %xmm12
unpckhpd %xmm9, %xmm9            # xmm9 = xmm9[1,1]
mulpd %xmm1, %xmm9
addpd %xmm2, %xmm9
movapd 0x60(%r14,%rbx), %xmm1
movapd 0xc0(%r12,%rbx,2), %xmm6
movapd 0xd0(%r12,%rbx,2), %xmm5
movapd %xmm6, %xmm7
unpcklpd %xmm6, %xmm7            # xmm7 = xmm7[0],xmm6[0]
mulpd %xmm1, %xmm7
addpd %xmm13, %xmm7
unpckhpd %xmm6, %xmm6            # xmm6 = xmm6[1,1]
mulpd %xmm1, %xmm6
addpd %xmm8, %xmm6
movapd %xmm5, %xmm8
unpcklpd %xmm5, %xmm8            # xmm8 = xmm8[0],xmm5[0]
mulpd %xmm1, %xmm8
addpd %xmm4, %xmm8
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
mulpd %xmm1, %xmm5
addpd %xmm3, %xmm5
movapd 0x70(%r14,%rbx), %xmm13
movapd 0xe0(%r12,%rbx,2), %xmm3
movapd 0xf0(%r12,%rbx,2), %xmm1
movapd %xmm3, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
mulpd %xmm13, %xmm4
addpd %xmm11, %xmm4
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
mulpd %xmm13, %xmm3
addpd %xmm10, %xmm3
movapd %xmm1, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
mulpd %xmm13, %xmm2
addpd %xmm12, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
mulpd %xmm13, %xmm1
addpd %xmm9, %xmm1
addq %r10, %r8
addq %rbp, %rbx
addq %r13, %rsi
cmpq %r11, %r8
jl 0x1d752
addpd %xmm7, %xmm4
addpd %xmm6, %xmm3
addpd %xmm8, %xmm2
addpd %xmm5, %xmm1
addq %r12, %rsi
addq %r14, %rbx
movq %rax, %r9
movq -0x60(%rsp), %rax
jmp 0x1da83
leaq (%rdi,%rsi,8), %rsi
xorpd %xmm4, %xmm4
movq %rax, %rbx
xorpd %xmm3, %xmm3
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
movq %rax, %r9
movq -0x60(%rsp), %rax
movq 0x68(%rsp), %r10
cmpq %r11, 0x78(%rsp)
jle 0x1daea
xorl %r8d, %r8d
movq -0x70(%rsp), %rdi
movapd (%rbx,%r8), %xmm5
movapd (%rsi,%r8,2), %xmm6
movapd 0x10(%rsi,%r8,2), %xmm7
movapd %xmm6, %xmm8
unpcklpd %xmm6, %xmm8            # xmm8 = xmm8[0],xmm6[0]
mulpd %xmm5, %xmm8
addpd %xmm8, %xmm4
unpckhpd %xmm6, %xmm6            # xmm6 = xmm6[1,1]
mulpd %xmm5, %xmm6
addpd %xmm6, %xmm3
movapd %xmm7, %xmm6
unpcklpd %xmm7, %xmm6            # xmm6 = xmm6[0],xmm7[0]
mulpd %xmm5, %xmm6
addpd %xmm6, %xmm2
unpckhpd %xmm7, %xmm7            # xmm7 = xmm7[1,1]
mulpd %xmm5, %xmm7
addpd %xmm7, %xmm1
addq $0x10, %r8
decq %rdi
jne 0x1da92
movq -0x10(%rsp), %rsi
movupd (%rsi), %xmm5
movupd (%rdx), %xmm6
mulpd %xmm0, %xmm4
addpd %xmm5, %xmm4
mulpd %xmm0, %xmm3
addpd %xmm6, %xmm3
movupd %xmm4, (%rsi)
movupd %xmm3, (%rdx)
movq -0x8(%rsp), %rdx
movupd (%rdx), %xmm3
movupd (%r15), %xmm4
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
mulpd %xmm0, %xmm1
addpd %xmm4, %xmm1
movupd %xmm2, (%rdx)
movupd %xmm1, (%r15)
addq $0x4, %rcx
addq -0x18(%rsp), %r12
cmpq 0x80(%rsp), %rcx
jl 0x1d68b
movq 0x70(%rsp), %rcx
cmpq %rcx, 0x80(%rsp)
movq -0x38(%rsp), %r12
movq -0x70(%rsp), %r15
jge 0x1dd0d
movq -0x78(%rsp), %rcx
imulq 0x38(%rsp), %rcx
movq -0x68(%rsp), %rdx
leaq (%rdx,%rcx,8), %rcx
movq -0x48(%rsp), %rdx
movq 0x80(%rsp), %rsi
prefetcht0 (%rcx)
movq -0x50(%rsp), %rdi
movq 0x8(%rdi), %r8
imulq %rsi, %r8
shlq $0x3, %r8
addq (%rdi), %r8
testq %r11, %r11
jle 0x1dca2
xorpd %xmm1, %xmm1
xorl %r9d, %r9d
xorl %edi, %edi
xorl %ebx, %ebx
movq %rdi, %r15
movupd (%r14,%rdi,2), %xmm2
movsd (%rdx,%rdi), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm2, %xmm3
addpd %xmm1, %xmm3
movupd 0x10(%r14,%rdi,2), %xmm1
movsd 0x8(%rdx,%rdi), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
addpd %xmm3, %xmm2
movupd 0x20(%r14,%rdi,2), %xmm1
movsd 0x10(%rdx,%rdi), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm1, %xmm3
addpd %xmm2, %xmm3
movupd 0x30(%r14,%rdi,2), %xmm1
movsd 0x18(%rdx,%rdi), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
addpd %xmm3, %xmm2
movupd 0x40(%r14,%rdi,2), %xmm1
movsd 0x20(%rdx,%rdi), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm1, %xmm3
addpd %xmm2, %xmm3
movupd 0x50(%r14,%rdi,2), %xmm1
movsd 0x28(%rdx,%rdi), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
addpd %xmm3, %xmm2
movupd 0x60(%r14,%rdi,2), %xmm1
movsd 0x30(%rdx,%rdi), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm1, %xmm3
addpd %xmm2, %xmm3
movupd 0x70(%r14,%rdi,2), %xmm2
movsd 0x38(%rdx,%rdi), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm2, %xmm1
addpd %xmm3, %xmm1
addq %r10, %rbx
addq %rax, %rdi
addq %rbp, %r9
cmpq %r11, %rbx
jl 0x1dbb6
addq %rdx, %r15
leaq (%r15,%r10,8), %rdi
addq %r14, %r9
movq -0x70(%rsp), %r15
jmp 0x1dcb6
movq %rsi, %rdi
imulq 0x40(%rsp), %rdi
leaq (%r12,%rdi,8), %rdi
xorpd %xmm1, %xmm1
movq %rcx, %r9
cmpq %r11, 0x78(%rsp)
jle 0x1dce1
xorl %ebx, %ebx
movupd (%r9), %xmm2
movsd (%rdi,%rbx,8), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm2, %xmm3
addpd %xmm3, %xmm1
addq $0x10, %r9
incq %rbx
cmpq %rbx, %r15
jne 0x1dcbf
movq -0x78(%rsp), %rdi
movupd (%r8,%rdi,8), %xmm2
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
movupd %xmm1, (%r8,%rdi,8)
incq %rsi
addq -0x28(%rsp), %rdx
cmpq 0x70(%rsp), %rsi
jne 0x1db8b
movq -0x78(%rsp), %rcx
addq $0x2, %rcx
addq -0x40(%rsp), %r14
movq %rcx, -0x78(%rsp)
cmpq -0x30(%rsp), %rcx
jl 0x1d661
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq