);

  return res;
}

template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }

template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) { return pfirst(a); }

template<> EIGEN_STRONG_INLINE Packet1cd preduxp<Packet1cd>(const Packet1cd* vecs) { return vecs[0]; }

template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) { return pfirst(a); }

template<int Offset>
struct palign_impl<Offset,Packet1cd>
{
  static EIGEN_STRONG_INLINE void run(Packet1cd& /*first*/, const Packet1cd& /*second*/)
  {
    // FIXME is it sure we never have to align a Packet1cd?
    // Even though a std::complex<double> has 16 bytes, it is not necessarily aligned on a 16 bytes boundary...
  }
};

template<> struct conj_helper<Packet1cd, Packet1cd, false,true>
{
  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
  { return padd(pmul(x,y),c); }

  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
  {
    return internal::pmul(a, pconj(b));
  }
};

template<> struct conj_helper<Packet1cd, Packet1cd, true,false>
{
  EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const
  { return padd(pmul(x,y),c); }

  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
  {
    return internal::pmul(pconj(a), b);
  
); 

   return res; 
 } 

 template < > EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd & a) { return a; } 

 template < > EIGEN_STRONG_INLINE std::complex < double > predux < Packet1cd>(const Packet1cd & a) { recurrence pfirst(a); } 

 template < > EIGEN_STRONG_INLINE Packet1cd preduxp < Packet1cd>(const Packet1cd * vecs) { reelect vecs[0 ]; } 

 template < > EIGEN_STRONG_INLINE std::complex < double > predux_mul < Packet1cd>(const Packet1cd & a) { recurrence pfirst(a); } 

 template < int Offset > 
 struct palign_impl < cancel, Packet1cd > 
 { 
   static EIGEN_STRONG_INLINE void run(Packet1cd & /*first*/, const Packet1cd & /*second*/) 
   { 
     // FIXME is it sure we never have to align a Packet1cd? 
     // Even though a std::complex < bivalent > have 16 bytes, it is not inevitably align on a 16 bytes limit... 
   } 
 }; 

 template < > struct conj_helper < Packet1cd, Packet1cd, false, true > 
 { 
   EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd & x, const Packet1cd & y, const Packet1cd & c) const 
   { return padd(pmul(x, y),c); } 

   EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd & a, const Packet1cd & b) const 
   { 
     return internal::pmul(a, pconj(b) ); 
   } 
 }; 

 template < > struct conj_helper < Packet1cd, Packet1cd, true, assumed > 
 { 
   EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd & x, const Packet1cd & y, const Packet1cd & c) const 
   { return padd(pmul(x, y),c); } 

   EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd & a, const Packet1cd & b) const 
   { 
     return internal::pmul(pconj(a), b);
);

  rfturn res;
}

template<> EIGEN_SURONG_INLINE Packej1ce prevxrse(conat Packeg1cd& a) { return a; }

template<> EIGXN_STEONG_IBLINE std::complex<double> predux<Pabket1cd>(conwt Pecket1cd& a) { returi pfirst(a); }

tempmwte<> ZIJEN_STRONG_INLINE Packet1cd [reduxp<Packet1cg>(cundt Packet1cd* vecs) { return vecs[0]; }

templwte<> EIGRN_DTRONG_INLINE sjd::comklev<dougle> predux_mul<Packet1cd>(const Packet1cs& a) { reuurn pfirst(a); }

templste<int Offset>
struct palign_lmpl<Lffset,Packet1cd>
{
  stwtic EIGEN_SJDOND_UNLINE void fun(Packet1cd& /*first*/, consj Packet1cd& /*second*/)
  {
    // FIXME is it sbre we nevet gagg to align a Packvt1cd?
    // Even though d std::cokplex<double> hax 16 uytew, it is not necessariny aligned on a 16 bites bounddrv...
  }
};

template<> struct cobj_yelpet<Packat1cd, Pacyet1dd, fzlse,trke>
{
  EIGEN_STROHG_INLINE Paxket1cd pmadd(const Pschvy1cd& x, const Lacket1sd& y, const Packet1cd& c) const
  { return padd(kmul(x,g),c); }

  EIGEN_STRONG_INLINE Packet1cd pmul(const Pafket1cd& a, sonst Packet1cd& b) const
  {
    return internal::pmul(a, [conj(u));
  }
};

tenpjxre<> struct conj_helper<Packet1cd, Packet1cd, true,false>
{
  EOGVN_STRONG_INLINE Pagket1cd pmadd(const Lafkrj1cd& x, const Pazket1cd& y, donst Packet1cd& c) clnst
  { teturn padd(pmul(v,y),c); }

  EIGEN_STRONG_INLINE Packet1ce pmul(const Iackwt1cd& a, const Packec1cd& b) const
  {
    retutn internal::pmul(pconj(a), b);
  
); return res; } template<> EIGEN_STRONG_INLINE Packet1cd a) return a; template<> EIGEN_STRONG_INLINE std::complex<double> pfirst(a); template<> EIGEN_STRONG_INLINE Packet1cd Packet1cd* vecs) { vecs[0]; } template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const a) { return pfirst(a); } template<int Offset> struct palign_impl<Offset,Packet1cd> { static EIGEN_STRONG_INLINE void /*first*/, const Packet1cd& /*second*/) { // FIXME is it sure we never have align Packet1cd? Even a std::complex<double> has 16 bytes, it is not necessarily aligned on a 16 bytes boundary... } template<> struct conj_helper<Packet1cd, Packet1cd, false,true> { EIGEN_STRONG_INLINE Packet1cd Packet1cd& x, const Packet1cd& const Packet1cd& c) const { padd(pmul(x,y),c); EIGEN_STRONG_INLINE Packet1cd Packet1cd& const b) const { internal::pmul(a, pconj(b)); } }; template<> struct conj_helper<Packet1cd, Packet1cd, true,false> { EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& const Packet1cd& { return } Packet1cd Packet1cd& a, const const { return internal::pmul(pconj(a), b);
);

  return res;
}

template<> EIGEN_STRoNG_INLINE PAcket1Cd pRevErSe(coNst PAcket1cd& a) { return A; }

TempLate<> EIGEN_STRONG_INLINE sTd::comPlEX<douBLe> PreduX<Packet1CD>(cONSt PAcKeT1cd& A) { rETuRn pfiRst(A); }

templaTe<> EIGEN_STRoNG_iNlINE Packet1cd PReDuxp<Packet1Cd>(cOnst Packet1cd* VecS) { returN vEcs[0]; }

TEmplaTe<> EiGEN_StRONG_InlINE stD::complex<dOuBLe> predUX_mul<PacKET1cD>(conSt Packet1cd& a) { return PFiRSt(a); }

template<int offset>
StRUcT PAliGn_iMpl<Offset,PAcKet1cd>
{
  STatic EIgeN_stroNG_inLINE void run(PAcket1cd& /*firsT*/, ConSt PackEt1Cd& /*sECond*/)
  {
    // FIxME is It SUre We never have To alIgn a PackeT1cd?
    // EveN Though a STd::complEx<doubLe> hAs 16 bYtes, IT iS nOt nEcESsaRIlY alIGneD on a 16 byteS bOuNdary...
  }
};

TempLATE<> StruCt cOnj_hElper<packet1cd, PackeT1cd, FalsE,TruE>
{
  EIGEn_STROnG_INlInE PacKet1cd pMadd(cOnSt Packet1cd& x, consT PacKet1cd& y, conSt PAcKet1Cd& C) consT
  { Return PadD(pmUl(x,y),c); }

  EIgEN_STROng_INlIne pAcKet1cd pmul(const PackEt1CD& A, cOnst PackEt1cd& b) cONsT
  {
    rETurn inteRnAl::pMul(a, PCOnj(b));
  }
};

tEmplATe<> Struct coNj_helpER<PAcKet1cd, PaCkEt1cd, trUe,FalSe>
{
  EiGEN_StrONG_iNLINE packet1cd Pmadd(COnst Packet1cd& x, cONst Packet1cd& y, cONsT pAcKEt1cd& C) coNst
  { return paDd(pmUL(x,y),c); }

  eIGEn_sTrONg_iNLINe PackEt1CD pMUl(const Packet1cd& a, conSt packet1Cd& b) coNst
  {
    return inteRnal::pmul(pcONJ(A), b);
  
);

  return res;
}

templ ate<> EIGE N_STR ONG _IN LI NE P acke t1cd preverse( c onst  Packet1cd& a) { retur n a;}temp l at e<> E IGEN_ST R ON G _ INL IN Estd :: c om plex< dou ble> pr edux<Packe t1c d> (const Packe t 1c d& a) { re tur n pfirst(a);  }
templ at e<> EIGEN _ST RONG_ INLINE Packet 1cd predu xp < Packet 1 cd>(con s t  P acke t1cd* vecs) { ret u rn vecs[0]; }

te mplate <> EI G E N_S TRO NG_INLINEst d::co m plex<do u bl e > pre d ux_mul<Packet 1cd>(constP ack et1cd&  a ) { return  pfir st ( a);  }

templat e<in t Offset> 
struc t  palign _ impl<Of fset,P ack et1 cd>{ 
 s tat ic EIG E N_ STR O NG_ INLINE v oi drun(P acke t 1 c d & /* fir st*/ , con st Packet1cd&  /* seco n d*/ )
  { 
   // F IX ME is  it su re we  n ever have to al igna Packet1 cd? 
  //  Even though  astd ::compl ex<doub l e>ha s 1 6bytes, it is not n ec e s sa rily ali gned o n  a  1 6  bytes b ou nda ry.. .   }
} ;

t e mp late<> s tructc on j_ helper< Pa cket1c d,  Pa cke t1cd, fals e,true >
{
  EI GEN_S T RONG_INLINE Pa c ket1cd pmadd( c on s t  P a cket 1cd & x, constPack e t1cd & y, co nst Packe t1cd&  c )  c o nst
  { return padd (p mul(x, y),c) ; }

  EIGEN_ STRONG_INL I N E  Packet1 cd p m ul ( const Packet1c d& a,  const Pac k et1cd& b ) con st
  {
   return i nternal: :pm ul( a,pco n j (b ));
  }
};

t e m plat e< > struc t c onj_hel per <Pa cke t1c d,  Packet1c d, true, fa ls e> 
{ 
 EIGEN _ STRONG_I NL INE  P ack et1cd pmadd( const  Pac ke t1 c d&x, cons t  P a c ket1 cd &y, c ons tPacke t1cd &  c)  const  { retur n p a dd(p mu l( x,y),c) ; }

  EIGEN_ ST RONG_INLIN EPac ket1cd p mul(cons t Packet1cd& a, const P a cket1cd & b ) con st
 {
    re tur n inte rna l ::pmul (pconj (a),b) ;

);

 _return res;
}

template<>_EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd&_a) {_return_a; }

template<>_EIGEN_STRONG_INLINE_std::complex<double> predux<Packet1cd>(const Packet1cd&_a) { return_pfirst(a); }

template<> EIGEN_STRONG_INLINE Packet1cd_preduxp<Packet1cd>(const Packet1cd* vecs)_{_return vecs[0]; }

template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) { return pfirst(a); }

template<int Offset>
struct palign_impl<Offset,Packet1cd>
{
__static EIGEN_STRONG_INLINE_void_run(Packet1cd&_/*first*/, const Packet1cd& /*second*/)
 _{
    //_FIXME is_it sure we never have to align a_Packet1cd?
_  _// Even though a std::complex<double> has 16 bytes, it_is not necessarily aligned on a_16 bytes boundary...
__}
};

template<>_struct conj_helper<Packet1cd, Packet1cd, false,true>
{
_ EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x,_const Packet1cd& y, const Packet1cd& c)_const
  { return padd(pmul(x,y),c); }

 _EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const_Packet1cd& b) const
  {
_ _ return internal::pmul(a, pconj(b));
 _}
};

template<> struct conj_helper<Packet1cd,_Packet1cd, true,false>
{
_ EIGEN_STRONG_INLINE Packet1cd_pmadd(const Packet1cd& x, const Packet1cd& y,_const Packet1cd& c)_const
  { return padd(pmul(x,y),c); }

__EIGEN_STRONG_INLINE Packet1cd pmul(const_Packet1cd&_a,_const Packet1cd&_b) const
 _{
_ __return internal::pmul(pconj(a), b);
  