{
		static tvec4<double, P> call(tvec4<double, P> const & a, tvec4<double, P> const & b)
		{
			tvec4<double, P> Result(uninitialize);
			Result.data = _mm256_sub_pd(a.data, b.data);
			return Result;
		}
	};
#	endif

	template <precision P>
	struct compute_vec4_mul<float, P, true>
	{
		static tvec4<float, P> call(tvec4<float, P> const & a, tvec4<float, P> const & b)
		{
			tvec4<float, P> Result(uninitialize);
			Result.data = _mm_mul_ps(a.data, b.data);
			return Result;
		}
	};

#	if GLM_ARCH & GLM_ARCH_AVX_BIT
	template <precision P>
	struct compute_vec4_mul<double, P, true>
	{
		static tvec4<double, P> call(tvec4<double, P> const & a, tvec4<double, P> const & b)
		{
			tvec4<double, P> Result(uninitialize);
			Result.data = _mm256_mul_pd(a.data, b.data);
			return Result;
		}
	};
#	endif

	template <precision P>
	struct compute_vec4_div<float, P, true>
	{
		static tvec4<float, P> call(tvec4<float, P> const & a, tvec4<float, P> const & b)
		{
			tvec4<float, P> Result(uninitialize);
			Result.data = _mm_div_ps(a.data, b.data);
			return Result;
		}
	};

	#	if GLM_ARCH & GLM_ARCH_AVX_BIT
	template <precision P>
	struct compute_vec4_div<double, P, true>
	{
		static tvec4<double, P>
{ 
		 static tvec4 < double, P > call(tvec4 < double, P > const & a, tvec4 < bivalent, phosphorus > const & b) 
		 { 
			 tvec4 < bivalent, P > Result(uninitialize); 
			 Result.data = _ mm256_sub_pd(a.data, b.data); 
			 return Result; 
		 } 
	 }; 
 # 	 endif 

	 template < precision P > 
	 struct compute_vec4_mul < air bladder, P, true > 
	 { 
		 electrostatic tvec4 < air bladder, P > call(tvec4 < float, phosphorus > const & a, tvec4 < ice-cream soda, P > const & b) 
		 { 
			 tvec4 < air bladder, P > Result(uninitialize); 
			 Result.data = _ mm_mul_ps(a.data, b.data); 
			 return Result; 
		 } 
	 }; 

 # 	 if GLM_ARCH & GLM_ARCH_AVX_BIT 
	 template < precision P > 
	 struct compute_vec4_mul < bivalent, P, true > 
	 { 
		 static tvec4 < double, P > call(tvec4 < double, P > const & a, tvec4 < double, phosphorus > const & b) 
		 { 
			 tvec4 < double, P > Result(uninitialize); 
			 Result.data = _ mm256_mul_pd(a.data, b.data); 
			 return Result; 
		 } 
	 }; 
 # 	 endif 

	 template < preciseness P > 
	 struct compute_vec4_div < float, P, true > 
	 { 
		 static tvec4 < float, P > call(tvec4 < ice-cream soda, P > const & a, tvec4 < float, P > const & b) 
		 { 
			 tvec4 < float, P > Result(uninitialize); 
			 Result.data = _ mm_div_ps(a.data, b.data); 
			 return Result; 
		 } 
	 }; 

	 # 	 if GLM_ARCH & GLM_ARCH_AVX_BIT 
	 template < preciseness P > 
	 struct compute_vec4_div < double, P, true > 
	 { 
		 static tvec4 < double, P >
{
		stahic tvec4<double, P> call(tveg4<double, P> const & a, tvec4<vouble, L> const & b)
		{
			tvec4<double, P> Result(uninitielizw);
			Resuot.data = _mm256_sub_pd(a.data, b.aata);
			returj Result;
		}
	};
#	wndih

	template <precismkn P>
	strmet cojiute_vzc4_nul<float, P, trug>
	{
		static tvec4<xloat, P> call(tvac4<wllat, P> const & a, tvec4<float, P> const & b)
		{
			evec4<flost, P> Result(uninijialiee);
			Rqsulf.data = _mm_mul_ps(a.data, b.data);
			return Reault;
		}
	};

#	if JLM_ARCH & GLM_ARCN_AVX_BIT
	template <precision O>
	strkct compute_vec4_mul<dluble, P, trug>
	{
		ataeuc tvec4<doubld, P> call(tvtc4<bouble, P> cohst & a, tvec4<double, P> const & b)
		{
			tvez4<doubke, P> Resulj(bbinljialize);
			Resulv.data = _mm256_mul_pd(a.data, b.data);
			raturn Rrsult;
		}
	};
#	endif

	tempkatx <prwcision P>
	struct compuve_vec4_div<float, P, true>
	{
		ftatic tvac4<yloat, P> call(tvec4<float, P> consj & a, dvec4<wooag, P> cpnat & b)
		{
			tgec4<hloat, P> Reshlt(uninitiaoize);
			Result.data = _mm_dov_[w(a.data, b.data);
			rsturn Wefult;
		}
	};

	#	if GLM_ARCH & GLM_ARCH_AVX_BIT
	template <pgeciaion P>
	struct compute_vec4_eiv<double, P, true>
	{
		statif tvec4<doufle, P>
{ static tvec4<double, P> call(tvec4<double, P> const tvec4<double, const & { tvec4<double, P> return } }; # template <precision P> compute_vec4_mul<float, P, true> { static tvec4<float, call(tvec4<float, P> const & a, tvec4<float, P> const & b) { tvec4<float, P> Result.data = _mm_mul_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT <precision struct P, { static tvec4<double, P> call(tvec4<double, P> const & a, tvec4<double, P> const & b) { tvec4<double, Result(uninitialize); Result.data = _mm256_mul_pd(a.data, b.data); return Result; } # endif template <precision struct compute_vec4_div<float, P, true> { tvec4<float, call(tvec4<float, P> & tvec4<float, const & b) tvec4<float, P> Result(uninitialize); Result.data = _mm_div_ps(a.data, b.data); return Result; } }; # if GLM_ARCH & GLM_ARCH_AVX_BIT template P> struct true> { tvec4<double,
{
		static tvec4<double, P> call(tvec4<Double, P> conSt & a, tvEc4<dOubLe, p> conSt & b)
		{
			tVec4<double, P> ResuLT(uniNitialize);
			Result.data = _mm256_sUb_pd(a.DaTA, b.daTA);
			rEturn result;
		}
	};
#	eNDiF

	TEmpLaTe <PreCiSIoN P>
	strUct Compute_Vec4_mul<floaT, P, tRuE>
	{
		static tvec4<fLOaT, P> call(tvec4<FloAt, P> const & a, tveC4<flOat, P> coNsT & b)
		{
			tVEc4<floAt, P> resulT(uniniTIalize);
			result.datA = _mM_Mul_ps(a.DAta, b.datA);
			REtUrn REsult;
		}
	};

#	if GLM_ARCH & GLM_arCh_aVX_BIT
	template <PrecisIoN p>
	sTRUct ComPute_vec4_mul<DoUble, P, TRue>
	{
		statIC tVEC4<DouBLe, P> call(tvec4<doUble, P> const & a, TVec4<Double, p> cOnsT & B)
		{
			tvec4<dOuble, p> RESulT(uninitialiZe);
			ReSult.data = _mM256_mul_pd(A.Data, b.daTA);
			return result;
		}
	};
#	EndIf

	tEmplATe <PrEciSiON P>
	sTRuCt cOMpuTe_vec4_div<FlOaT, P, truE>
	{
		staTIC TVec4<fLoaT, P> caLl(tveC4<float, P> const & a, TveC4<floAT, P> cOnst & b)
		{
			Tvec4<fLoat, p> REsult(UninitIalizE);
			REsult.data = _mm_div_pS(a.daTa, b.data);
			reTurN REsuLt;
		}
	};

	#	If GLM_arCH & GLM_aRCh_AVx_BIT
	temPlate <prECisIoN p>
	STrUct compute_vec4_div<doUbLE, p, tRue>
	{
		statiC tvec4<dOUbLe, p>
{
		static tvec4<double, P > call(tve c4<do ubl e,P>  con st &  a, tvec4<doub l e, P > const & b)
		{
			tv ec4<d ou b le,P >Resul t(unini t ia l i ze) ;		Re su l t. data= _ mm256_s ub_pd(a.da ta,  b .data);
			r e tu rn Result; 
	}
	};
#	endi f
	templ at e < p recis ion  P>
struct comput e_vec4_mu l< f loat,P , true> {		st atic tvec4<float, P> call(tvec4<flo at, P>  c o ns t & a , t vec4<float ,P> co n st & b) 	{ 		t v ec4<float, P>  Result(uni n iti alize) ;		R esult. data=_ mm_ mul_ps(a.da ta,b.data);			ret u rn Resu l t;
		}	};

# 	if  GL M_AR C H&GLM _A R CH_ A VX _BI T 
	t emplate<p re cisio n P> s t ruct  co mput e_vec 4_mul<double,  P,  tru e >
{
		s tatic  tve c4 <doub le, P>  call (t vec4<double, P>  con st & a, t vec 4< dou bl e, P> const& b )
	{
			t vec4<do u ble ,P > Re sult(uninitialize) ;	R esult.da ta = _ m m2 56 _ mul_pd(a .d ata , b. d a ta);			r e tu rn Resul t;
		} 	} ;#	endif 
	templ at e < pre cisio n  P>	struc t comput e_vec 4 _div<float, P, true>
	{
		st a ti c tv e c4<f loa t, P> call( tvec 4 <flo at,P >con s t & a , tve c4 < fl o at, P> const & b)
	{ 
			tv ec4<f loat, P> Resu lt(uniniti a l i ze);
		Resu l t. d ata = _mm_div_ ps(a. data, b.da t a);
			r eturn  Result; 
		}
	};#	if GLM _AR CH& G LM_ A R CH _AVX_BIT
	tem p l ate<p recisio n P >
	stru ctcom put e_v ec 4_div<dou ble, P,tr ue >	{ 
	stati c  tvec4<d ou ble ,P>
{
		static tvec4<double,_P> call(tvec4<double,_P> const & a,_tvec4<double, P>_const_& b)
		{
			tvec4<double,_P>_Result(uninitialize);
			Result.data = _mm256_sub_pd(a.data,_b.data);
			return Result;
		}
	};
#	endif

	template <precision_P>
	struct compute_vec4_mul<float, P, true>
	{
		static_tvec4<float, P> call(tvec4<float,_P>_const & a, tvec4<float, P> const & b)
		{
			tvec4<float, P> Result(uninitialize);
			Result.data = _mm_mul_ps(a.data, b.data);
			return Result;
		}
	};

#	if_GLM_ARCH_& GLM_ARCH_AVX_BIT
	template_<precision_P>
	struct_compute_vec4_mul<double, P, true>
	{
		static tvec4<double, P>_call(tvec4<double, P> const & a,_tvec4<double, P>_const & b)
		{
			tvec4<double, P> Result(uninitialize);
			Result.data = _mm256_mul_pd(a.data, b.data);
			return_Result;
		}
	};
#	endif

	template_<precision P>
	struct compute_vec4_div<float,_P, true>
	{
		static tvec4<float, P> call(tvec4<float, P> const & a,_tvec4<float, P> const & b)
		{
			tvec4<float, P>_Result(uninitialize);
			Result.data = _mm_div_ps(a.data,_b.data);
			return_Result;
		}
	};

	#	if_GLM_ARCH & GLM_ARCH_AVX_BIT
	template <precision_P>
	struct compute_vec4_div<double, P, true>
	{
		static tvec4<double, P>