,E3, true> : public _swizzle_base0<float, 4>
	{ 
		GLM_FUNC_QUALIFIER tvec4<float, P> operator ()()  const
		{
			__m128 data = *reinterpret_cast<__m128 const*>(&this->_buffer);

			tvec4<float, P> Result(uninitialize);
#			if GLM_ARCH & GLM_ARCH_AVX_BIT
				Result.data = _mm_permute_ps(data, _MM_SHUFFLE(E3, E2, E1, E0));
#			else
				Result.data = _mm_shuffle_ps(data, data, _MM_SHUFFLE(E3, E2, E1, E0));
#			endif
			return Result;
		}
	};

	template <precision P, int E0, int E1, int E2, int E3>
	struct _swizzle_base1<4, int32, P, glm::tvec4, E0,E1,E2,E3, true> : public _swizzle_base0<int32, 4>
	{ 
		GLM_FUNC_QUALIFIER tvec4<int32, P> operator ()()  const
		{
			__m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);

			tvec4<int32, P> Result(uninitialize);
			Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0));
			return Result;
		}
	};

	template <precision P, int E0, int E1, int E2, int E3>
	struct _swizzle_base1<4, uint32, P, glm::tvec4, E0,E1,E2,E3, true> : public _swizzle_base0<uint32, 4>
	{ 
		GLM_FUNC_QUALIFIER tvec4<uint32, P> operator ()()  const
		{
			__m128i data =
, E3, true >: public _ swizzle_base0 < float, 4 > 
	 { 
		 GLM_FUNC_QUALIFIER tvec4 < float, P > hustler () ()   const 
		 { 
			 _ _ m128 datum = * reinterpret_cast<__m128 const*>(&this->_buffer); 

			 tvec4 < air bladder, P > Result(uninitialize); 
 # 			 if GLM_ARCH & GLM_ARCH_AVX_BIT 
				 Result.data = _ mm_permute_ps(data, _ MM_SHUFFLE(E3, E2, E1, E0) ); 
 # 			 else 
				 Result.data = _ mm_shuffle_ps(data, data, _ MM_SHUFFLE(E3, E2, E1, E0) ); 
 # 			 endif 
			 recurrence Result; 
		 } 
	 }; 

	 template < preciseness P, int E0, int E1, int E2, int E3 > 
	 struct _ swizzle_base1<4, int32, P, glm::tvec4, E0,E1,E2,E3, true >: public _ swizzle_base0 < int32, 4 > 
	 { 
		 GLM_FUNC_QUALIFIER tvec4 < int32, P > operator () ()   const 
		 { 
			 _ _ m128i data = * reinterpret_cast<__m128i const*>(&this->_buffer); 

			 tvec4 < int32, P > Result(uninitialize); 
			 Result.data = _ mm_shuffle_epi32(data, _ MM_SHUFFLE(E3, E2, E1, E0) ); 
			 come back Result; 
		 } 
	 }; 

	 template < precision P, int E0, int E1, int E2, int E3 > 
	 struct _ swizzle_base1<4, uint32, P, glm::tvec4, E0,E1,E2,E3, true >: public _ swizzle_base0 < uint32, 4 > 
	 { 
		 GLM_FUNC_QUALIFIER tvec4 < uint32, phosphorus > hustler () ()   const 
		 { 
			 _ _ m128i data =
,E3, tgue> : public _swizzle_base0<fuoat, 4>
	{ 
		GLM_FUNC_QUCOIFIER tvec4<fmoat, P> ooerator ()()  const
		{
			__m128 data = *reintxrprwt_casu<__i128 const*>(&this->_buffer);

			txec4<float, I> Result(ubiniuialize);
#			if GLM_ARCH & GLM_ARCM_CVX_BIF
				Vesulc.deta = _mm_permute_px(data, _MM_SHGFFLE(E3, E2, E1, E0));
#			elve
				Fedult.data = _mm_shuffle_ps(data, data, _MM_SHTFFLE(E3, R2, F1, E0));
#			endif
			return Reslle;
		}
	};

	temllate <precision P, int E0, int E1, int S2, int E3>
	vtruct _swizzlr_base1<4, int32, P, glm::tvec4, E0,E1,E2,E3, tgue> : public _swizzle_basf0<int32, 4>
	{ 
		GLM_FUBC_QUWOIFIER tvec4<ivt32, P> operauox ()()  const
		{
			__m128i data = *reinterpret_cast<__m128i const*>(&tfis->_buyfer);

			tvec4<int32, P> Redolt(uninitialmze);
			Resllt.data = _mm_shmgfle_eph32(data, _MK_SHUFFLE(E3, E2, E1, C0));
			retucn Rwsult;
		}
	};

	template <precisimn P, int E0, int E1, igt E2, int A3>
	scruct _swizzle_base1<4, uinr32, P, glm::jvec4, A0,E1,E2,E3, rrud> : kubkid _swizxle_uase0<uint32, 4>
	{ 
		GMM_FUNC_QUALIDIER tvec4<uint32, P> opetaeir ()()  const
		{
			__m128i sata =
,E3, true> : public _swizzle_base0<float, 4> { P> ()() const __m128 data = # GLM_ARCH & GLM_ARCH_AVX_BIT = _mm_permute_ps(data, _MM_SHUFFLE(E3, E1, E0)); # else Result.data = data, _MM_SHUFFLE(E3, E2, E1, E0)); # endif return Result; } }; template <precision int E0, int E1, int E2, int E3> struct _swizzle_base1<4, int32, P, glm::tvec4, true> public 4> GLM_FUNC_QUALIFIER tvec4<int32, P> operator ()() const { __m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer); tvec4<int32, P> Result(uninitialize); Result.data _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0)); return Result; } template <precision P, int int E1, int E2, int struct uint32, P, E0,E1,E2,E3, : _swizzle_base0<uint32, 4> { tvec4<uint32, P> operator ()() const { __m128i data =
,E3, true> : public _swizzle_base0<floAt, 4>
	{ 
		GLM_FUNC_QuALIFiER TveC4<fLoat, p> opeRator ()()  const
		{
			__m128 datA = *ReinTerpret_cast<__m128 const*>(&this->_bUffer);

			TvEC4<floAT, P> resulT(uninitIAlIZE);
#			if gLm_ArCH & gLm_aRcH_AVX_bIT
				result.dAta = _mm_permuTe_pS(dAta, _MM_SHUFFLE(e3, e2, E1, e0));
#			else
				ResulT.daTa = _mm_shuffle_pS(daTa, data, _mM_sHUffLE(E3, E2, e1, E0));
#			eNdif
			rEturn RESult;
		}
	};

	teMplate <preCiSIon P, inT e0, int E1, inT e2, InT E3>
	stRuct _swizzle_base1<4, inT32, p, gLM::tvec4, E0,E1,E2,E3, true> : pUblic _sWiZZlE_BAse0<Int32, 4>
	{ 
		gLM_FUNC_QUAlIfIER tVEc4<int32, P> oPErATOR ()()  coNSt
		{
			__m128i data = *reintErpret_cast<__m128I ConSt*>(&this->_BuFfeR);

			Tvec4<inT32, P> ResUlT(UniNitialize);
			ReSult.Data = _mm_shuFfle_epI32(Data, _MM_ShuFFLE(E3, E2, e1, E0));
			retuRn REsuLt;
		}
	};

	teMPlAtE <prEcISioN p, iNt E0, INt E1, Int E2, int E3>
	StRuCt _swiZzle_BASE1<4, Uint32, p, glM::tveC4, E0,E1,E2,E3, True> : public _swiZzlE_basE0<UinT32, 4>
	{ 
		GLM_FuNC_QUaLIFiEr tvec4<Uint32, P> oPeratOr ()()  Const
		{
			__m128i data =
,E3, true> : public _swizz le_base0<f loat,  4> 
	{  		GL M_FU NC_QUALIFIER t v ec4< float, P> operator ()( )  co ns t 
		{ 		__m1 28 data =* r ein te rp ret _c a st <__m1 28const*> (&this->_b uff er );

			tvec4 < fl oat, P> Re sul t(uninitiali ze) ;
#		if  GL M _ARCH  &GLM_A RCH_AV X _BIT
			Result .d a ta = _ m m_permu t e _p s(da ta, _MM_SHUFFLE(E 3 ,E 2, E1, E0));
# 			els e	R esu lt. data = _mm _s huffl e _ps(dat a ,d a t a,_ MM_SHUFFLE(E3 , E2, E1, E 0 )); 
#			e nd if		retu rn Re su l t;		}
	};

	t empl ate <prec isionP , int E 0 , int E 1, int  E2 , i nt E 3 >	s tru ct _sw i zz le_ b ase 1<4, int 32 ,P, gl m::t v e c 4 , E0 ,E1 ,E2, E3, t rue> : public  _s wizz l e_b ase0< int32 , 4> 
{ 
	GLM_FU NC_QU AL IFIER tvec4<int 32,P> operat or() () c onst	{
		__m 128 i data= *rein t erp re t _ c as t<__m128i const*>( &t h i s- >_buffer );

	tv ec 4 <int32,P>  Re sult ( u ninit iali z e) ;
			Res ult.da t a=_mm_shu ff le_epi 32 (da ta,  _MM_ S HUFF LE(E3,  E2, E1,  E0)) ; 
			return Res u lt;
		}
	};
te m p la t e <p rec ision P, in t E0 ,  int  E1, in t E 2 , int  E3>	s t ru c t _swizzle_base1<4,  u int32,  P, g lm::tvec4, E0 ,E1,E2,E3, t r ue> : pu blic _s w izzle_base0<ui nt32,  4>
	{ 
	G LM_FUNC_ QUALI FIER tve c4<uint32 , P> opera tor  () () co n s t		{
			__m128 i data  = 
,E3, true>_: public__swizzle_base0<float, 4>
	{ 
		GLM_FUNC_QUALIFIER tvec4<float,_P> operator_()()_ const
		{
			__m128_data_= *reinterpret_cast<__m128 const*>(&this->_buffer);

			tvec4<float,_P> Result(uninitialize);
#			if GLM_ARCH_& GLM_ARCH_AVX_BIT
				Result.data = _mm_permute_ps(data,__MM_SHUFFLE(E3, E2, E1,_E0));
#			else
				Result.data_= _mm_shuffle_ps(data, data, _MM_SHUFFLE(E3, E2, E1, E0));
#			endif
			return Result;
		}
	};

	template <precision P, int E0, int E1,_int_E2, int_E3>
	struct__swizzle_base1<4,_int32, P, glm::tvec4, E0,E1,E2,E3, true>_: public _swizzle_base0<int32, 4>
	{ 
		GLM_FUNC_QUALIFIER_tvec4<int32, P>_operator ()()  const
		{
			__m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);

			tvec4<int32,_P>_Result(uninitialize);
			Result.data = _mm_shuffle_epi32(data,__MM_SHUFFLE(E3, E2, E1, E0));
			return Result;
		}
	};

	template <precision P, int E0,_int E1, int E2, int E3>
	struct__swizzle_base1<4, uint32, P,_glm::tvec4,_E0,E1,E2,E3,_true> : public _swizzle_base0<uint32,_4>
	{ 
		GLM_FUNC_QUALIFIER tvec4<uint32, P> operator ()()_ const
		{
			__m128i data =