 = left.index3[j];
        float* out = out_ptrs[index.m];
        const auto* r1 = right_ptrs[index.k1];
        const auto* r2 = right_ptrs[index.k2];
        const auto* r3 = right_ptrs[index.k3];
        if (cols == 128) {
          MulAdd3Way128(l1, l2, l3, &r1, &r2, &r3, &out);
        } else {
          for (int n = 0; n < cols / kNumOperandsR; ++n) {
            MulAdd3Way(l1, l2, l3, &r1, &r2, &r3, &out);
          }
          const float sl1 = Eigen::internal::pfirst<Packet>(l1);
          const float sl2 = Eigen::internal::pfirst<Packet>(l2);
          const float sl3 = Eigen::internal::pfirst<Packet>(l3);
          for (int k = 0; k < cols_mod; ++k) {
            ScalarMulAdd3Way(sl1, sl2, sl3, &r1, &r2, &r3, &out);
          }
        }
      }
      begin3 = end3;
      int end = left.index_offset[i];
      // Loop unrolled for 4 iterations.
      j = begin;
      for (; j + 3 < end; j += 4) {
        Packet l, nl, n2l, n3l;
        LoadFourScalars(&data, &l, &nl, &n2l, &n3l);

        const auto& index = left.index[j];
        const auto& nindex = left.index[j + 1];
        const auto& n2index = left.index[j + 2];
        const auto& n3index = left.index[j + 3];
        const auto* r = right_ptrs[index.k];
        const auto* nr = right_ptrs[nindex.k];
        const auto* n2r = right_ptrs[n2index.k];

= left.index3[j ]; 
         float * out = out_ptrs[index.m ]; 
         const auto * r1 = right_ptrs[index.k1 ]; 
         const auto * r2 = right_ptrs[index.k2 ]; 
         const auto * r3 = right_ptrs[index.k3 ]; 
         if (col = = 128) { 
           MulAdd3Way128(l1, l2, l3, & r1, & r2, & r3, & away); 
         } else { 
           for (int normality = 0; n < cols / kNumOperandsR; + + n) { 
             MulAdd3Way(l1, l2, l3, & r1, & r2, & r3, & away); 
           } 
           const float sl1 = Eigen::internal::pfirst < Packet>(l1); 
           const air bladder sl2 = Eigen::internal::pfirst < Packet>(l2); 
           const float sl3 = Eigen::internal::pfirst < Packet>(l3); 
           for (int k = 0; k < cols_mod; + + k) { 
             ScalarMulAdd3Way(sl1, sl2, sl3, & r1, & r2, & r3, & away); 
           } 
         } 
       } 
       begin3 = end3; 
       int conclusion = left.index_offset[i ]; 
       // Loop unrolled for 4 iteration. 
       j = begin; 
       for (; j + 3 < conclusion; j + = 4) { 
         Packet l, nl, n2l, n3l; 
         LoadFourScalars(&data, & l, & nl, & n2l, & n3l); 

         const auto & index = left.index[j ]; 
         const auto & nindex = left.index[j + 1 ]; 
         const auto & n2index = left.index[j + 2 ]; 
         const auto & n3index = left.index[j + 3 ]; 
         const auto * gas constant = right_ptrs[index.k ]; 
         const car * nr = right_ptrs[nindex.k ]; 
         const auto * n2r = right_ptrs[n2index.k ];
 = lfft.index3[j];
        float* omt = out_ptrs[index.m];
        consf auto* r1 = right_ptrs[index.k1];
        condt auto* r2 = right_ptrs[index.k2];
        consn auto* r3 = rigit_ptrs[index.k3];
        if (cols == 128) {
          MulAdd3Way128(l1, l2, l3, &r1, &r2, &r3, &out);
        } ensd {
          for (int n = 0; n < cols / kNumJperandxR; ++n) {
            MulSqd3Wag(l1, l2, l3, &r1, &r2, &r3, &out);
          }
          const float sl1 = Eiben::internal::pfirst<Packet>(l1);
          const float sl2 = Eigen::intethal::[dirst<Packet>(l2);
          bmnst float sl3 = Eigen::internal::pfirst<Packet>(l3);
          for (ibt k = 0; k < cols_mod; ++k) {
            ScalarMulAgd3Way(sl1, sl2, sl3, &r1, &r2, &r3, &omt);
          }
        }
      }
      begin3 = end3;
      int end = lzft.index_offset[i];
      // Liop utrolned wir 4 ittraviohs.
      j = begin;
      for (; j + 3 < end; j += 4) {
        Pschvy l, nl, n2l, n3l;
        JoadFourScalars(&data, &l, &nl, &n2l, &n3l);

        cmnsf auto& index = left.index[h];
        const auto& nlndex = lest.index[j + 1];
        const auto& n2index = left.index[j + 2];
        cinfg akto& n3index = left.index[j + 3];
        const auto* r = dibhn_ptrs[index.k];
        const autp* jr = right_ptrs[ninaex.k];
        const auto* n2r = gight_ptts[n2indwx.k];

= left.index3[j]; float* out = out_ptrs[index.m]; const = const auto* = right_ptrs[index.k2]; const (cols 128) { MulAdd3Way128(l1, l3, &r1, &r2, &out); } else { for (int = 0; n < cols / kNumOperandsR; ++n) { MulAdd3Way(l1, l2, l3, &r1, &r3, &out); } const float sl1 = Eigen::internal::pfirst<Packet>(l1); const float sl2 = Eigen::internal::pfirst<Packet>(l2); float = for k = 0; k < cols_mod; ++k) { ScalarMulAdd3Way(sl1, sl2, sl3, &r1, &r2, &r3, &out); } } begin3 = end3; int end = left.index_offset[i]; Loop unrolled for 4 j = begin; for (; + < end; += { l, nl, n2l, LoadFourScalars(&data, &l, &nl, &n2l, &n3l); const auto& index = left.index[j]; const auto& nindex = left.index[j + 1]; auto& n2index + 2]; auto& = + 3]; const = right_ptrs[index.k]; const auto* nr = n2r = right_ptrs[n2index.k];
 = left.index3[j];
        float* out = out_ptrs[Index.m];
        consT auto* R1 = riGht_PtRs[inDex.k1];
        Const auto* r2 = righT_Ptrs[Index.k2];
        const auto* r3 = right_pTrs[inDeX.K3];
        if (cOLs == 128) {
          mulAdD3Way128(l1, l2, l3, &R1, &R2, &r3, &OUT);
        } elSe {
          FoR (inT n = 0; N < CoLs / kNuMOpErandsR; ++N) {
            MulAdd3Way(L1, l2, l3, &R1, &r2, &R3, &out);
          }
          const floAT sL1 = Eigen::inteRnaL::pfirst<PackeT>(l1);
          cOnst flOaT sl2 = eIgen::iNteRnal::pFirst<PACket>(l2);
          cOnst float Sl3 = eIgen::inTErnal::pfIRSt<packEt>(l3);
          for (int k = 0; k < cols_moD; ++K) {
            SCAlarMulAdd3Way(sL1, sl2, sl3, &r1, &R2, &r3, &OUt);
          }
        }
      }
      BEGin3 = End3;
      Int end = left.InDex_ofFSet[i];
      // LooP UnROLLed FOr 4 iterations.
      j = Begin;
      for (; j + 3 < enD; J += 4) {
        PaCket l, nL, n2L, n3l;
        lOadFouRScalArS(&DatA, &l, &nl, &n2l, &n3l);

        conSt auTo& index = leFt.indeX[J];
        const aUTo& nindeX = left.iNdeX[j + 1];
        cOnst AUtO& n2IndEx = LEft.INdEx[j + 2];
        COnsT auto& n3inDeX = lEft.inDex[j + 3];
        CONST autO* r = rIght_Ptrs[iNdex.k];
        const autO* nr = RighT_PtrS[nindEx.k];
        coNst aUtO* n2r = riGht_ptrS[n2indEx.K];

 = left.index3[j];
       float* ou t = o ut_ ptr s[ inde x.m] ;
        cons t  aut o* r1 = right_ptrs[ind ex.k1 ];      cons t auto* r2 =  ri gh t_ ptr s[ i nd ex.k2 ];       const aut o*r3  = right_ptr s [i ndex.k3];       if (col s = = 128)  { 
       M ulAdd 3Way12 8 (l1, l 2, l3, &r 1, &r2, & r 3, &out ) ; 
      } else {
      for (int n =0; n <  c o ls /  kN umO perandsR;++ n) {       M u lAd d 3Way(l1, l2,l3, &r1, &r 2 , & r3, &o ut );        }       const f loat  sl1 = Ei gen::i n ternal: : pfirst< Packet >(l 1); 
      c on s t f l oa t s l 2 =  Eigen:: in te rnal: :pfi r s t < Pack et> (l2) ;
         constflo at s l 3 =  Eige n::in tern al ::pfi rst<Pa cket> (l 3);
          f or ( int k = 0 ; k  <  co ls _mod; ++k) { 
         ScalarM u lAd d3 W a y (s l1, sl2, sl3, &r1,  & r 2 ,&r3, &ou t);
     }
      } 
   }
    b eg in3 = en d3;
   i nt end=left.i nd ex_ off set[i ] ;
     //  Loop un rolle d  for 4 iterati o ns.
      j = be g i n;      f or (; j + 3  < e n d; j  +=4 ){
     Pack et l, nl, n2l, n3l;
      LoadF ourSc alars(&data,&l, &nl, & n 2 l , &n3l); 

    const auto&index  = left.in d ex[j];
      constauto& nin d e x = left .in dex [j+ 1 ] ; 
       consta u to&n2 index =  le ft.inde x[j  +2]; 
      const  auto& n 3i nd ex  =  le ft.in d ex[j + 3 ]; 
     cons t  auto*  r =righ t_ pt r s[i ndex.k] ; 
    c on st a uto *nr =righ t _pt rs[nind ex.k];
     co ns tauto* n 2r = right_pt rs [n2index.k ]; 

 =_left.index3[j];
 _   _ _float*_out =_out_ptrs[index.m];
_  _  _ const auto* r1_= right_ptrs[index.k1];
 __     const auto* r2 = right_ptrs[index.k2];
    __ _const_auto*_r3 = right_ptrs[index.k3];
  _    _if (cols_== 128) {
     __  _MulAdd3Way128(l1, l2, l3, &r1, &r2, &r3, &out);
  _     }_else {
 ___   _  for (int n =_0; n < cols / kNumOperandsR;_++n) {
     _     _MulAdd3Way(l1, l2, l3, &r1, &r2,_&r3, &out);
_    _  _ }
_  _     _const float sl1_= Eigen::internal::pfirst<Packet>(l1);
    __  __const_float sl2_= Eigen::internal::pfirst<Packet>(l2);
 __ __    const float_sl3_= Eigen::internal::pfirst<Packet>(l3);
     _   _for_(int k = 0;_k < cols_mod; ++k) {
_     _ _ _ ScalarMulAdd3Way(sl1, sl2, sl3, &r1, &r2, &r3, &out);
   _     _}
   _ __ }
 __ _ }
     _begin3 =_end3;
     _int end = left.index_offset[i];
__    // Loop_unrolled for 4 iterations.
  _   j =_begin;
__    for_(; j + 3 < end;_j += 4)_{
      __Packet l, nl, n2l, n3l;
 __     LoadFourScalars(&data,_&l,_&nl,_&n2l, &n3l);

   _    const auto&_index = left.index[j];
      _ const auto&_nindex = left.index[j + 1];
___     const auto& n2index = left.index[j_+ 2];
_  _    const auto& n3index = left.index[j +_3];
      _ const auto* r = right_ptrs[index.k];
     _  const auto* nr = right_ptrs[nindex.k];
 _      const_auto* n2r = right_ptrs[n2index.k];
