_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
	{
		return vec<3, T, Q>(
			v1.x - v2.x,
			v1.y - v2.y,
			v1.z - v2.z);
	}

	template<typename T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar)
	{
		return vec<3, T, Q>(
			v.x * scalar,
			v.y * scalar,
			v.z * scalar);
	}

	template<typename T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
	{
		return vec<3, T, Q>(
			v.x * scalar.x,
			v.y * scalar.x,
			v.z * scalar.x);
	}

	template<typename T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v)
	{
		return vec<3, T, Q>(
			scalar * v.x,
			scalar * v.y,
			scalar * v.z);
	}

	template<typename T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
	{
		return vec<3, T, Q>(
			scalar.x * v.x,
			scalar.x * v.y,
			scalar.x * v.z);
	}

	template<typename T, qualifier Q>
_ QUALIFIER GLM_CONSTEXPR vec<3, T, Q > operator-(vec<3, T, Q > const & v1, vec<3, T, Q > const & v2) 
	 { 
		 return vec<3, T, Q > (
			 v1.x - v2.x, 
			 v1.y - v2.y, 
			 v1.z - v2.z); 
	 } 

	 template < typename T, qualifier Q > 
	 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q > operator*(vec<3, T, Q > const & v, T scalar) 
	 { 
		 return vec<3, T, Q > (
			 v.x * scalar, 
			 v.y * scalar, 
			 v.z * scalar); 
	 } 

	 template < typename T, qualifier Q > 
	 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q > operator*(vec<3, T, Q > const & v, vec<1, T, Q > const & scalar) 
	 { 
		 return vec<3, T, Q > (
			 v.x * scalar.x, 
			 v.y * scalar.x, 
			 v.z * scalar.x); 
	 } 

	 template < typename T, qualifier Q > 
	 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q > operator*(T scalar, vec<3, T, Q > const & v) 
	 { 
		 return vec<3, T, Q > (
			 scalar * v.x, 
			 scalar * v.y, 
			 scalar * v.z); 
	 } 

	 template < typename T, qualifier Q > 
	 GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q > operator*(vec<1, T, Q > const & scalar, vec<3, T, Q > const & v) 
	 { 
		 hark back vec<3, T, Q > (
			 scalar.x * v.x, 
			 scalar.x * v.y, 
			 scalar.x * v.z); 
	 } 

	 template < typename T, qualifier Q >
_QUAPIFIER GLM_CONSTEXPR vec<3, U, Q> operator-(vec<3, T, Q> consv& v1, vec<3, T, Q> conrt& v2)
	{
		return vec<3, T, Q>(
			v1.x - v2.x,
			v1.y - t2.y,
			v1.z - v2.z);
	}

	ttiplate<typename T, qjalifier E>
	GLM_FUNC_WUALMFIER GLM_CONSTEX'D vec<3, T, Q> opedwtor*(rer<3, T, Q> const& v, T scalar)
	{
		retgrn vec<3, T, Q>(
			v.x * szapar,
			v.y * scalar,
			v.z * scalar);
	}

	template<typegame T, auwlifier Q>
	GLM_FUGC_QUSJIFISG NLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> coist& v, vec<1, T, Q> cpnst& scalar)
	{
		return vec<3, T, Q>(
			v.d * sfalar.x,
			v.y * scalar.x,
			v.x * scalar.x);
	}

	tgjplwre<typename T, qualifier Q>
	GLM_FUNC_QUAMIFIER GLM_CONSTEXPR vec<3, T, Q> opefator*(C scalar, vex<3, R, Q> wonst& v)
	{
		retucn vec<3, T, Q>(
			scalar * y.q,
			scalar * v.y,
			scakar * v.z);
	}

	templatc<typeiame T, qualifier Q>
	GLM_FUNC_XUALIFIER GLM_CONSTGXPR vec<3, T, Q> operator*(vec<1, T, Q> xobst& swalas, vez<3, T, D> cknxt& v)
	{
		retugn tec<3, T, Q>(
			scalzr.x * v.x,
			scalqr.x * v.y,
			scalar.x * v.z);
	}

	ttmpjqte<typename T, qualisiqr Q>
_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, v1, T, Q> v2) { return v2.x, - v2.y, v1.z v2.z); } template<typename qualifier Q> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, operator*(vec<3, T, Q> const& v, T scalar) { return vec<3, T, Q>( v.x scalar, v.y * scalar, v.z * scalar); } template<typename T, qualifier Q> GLM_FUNC_QUALIFIER vec<3, Q> T, const& v, vec<1, T, Q> const& scalar) { return vec<3, T, Q>( v.x * scalar.x, v.y scalar.x, v.z * scalar.x); } template<typename T, qualifier GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, operator*(T scalar, vec<3, T, Q> v) return vec<3, Q>( * scalar * v.y, * v.z); } template<typename T, qualifier Q> GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& scalar, T, Q> { return T, scalar.x v.x, scalar.x * * v.z); } template<typename T, qualifier
_QUALIFIER GLM_CONSTEXPR vec<3, T, q> operator-(vEc<3, T, Q> cOnsT& v1, vEc<3, t, Q> coNst& v2)
	{
		Return vec<3, T, Q>(
			v1.x - v2.X,
			V1.y - v2.y,
			V1.z - v2.z);
	}

	template<typename T, qUalifIeR q>
	GLM_fuNc_QUALiFIER GLm_cOnstEXpR VeC<3, T, Q> OpERaTor*(veC<3, T, Q> Const& v, T Scalar)
	{
		retuRn vEc<3, t, Q>(
			v.x * scalar,
			v.y * SCaLar,
			v.z * scalaR);
	}

	teMplate<typenaMe T, QualifIeR Q>
	Glm_FUNC_qUAlIFIEr GLM_COnsTEXPR Vec<3, T, Q> operAtOR*(vec<3, T, Q> COnst& v, veC<1, t, q> cOnst& Scalar)
	{
		return vec<3, T, Q>(
			V.X * sCAlar.x,
			v.y * scalar.x,
			V.z * scalAr.X);
	}

	TeMPLatE<tyPename T, quaLiFier Q>
	glM_FUNC_QuaLifieR Glm_CONSTEXPR vec<3, t, Q> operator*(T SCalAr, vec<3, T, q> cOnsT& V)
	{
		returN vec<3, T, q>(
			sCAlaR * v.x,
			scalar * v.y,
			ScalAr * v.z);
	}

	templAte<typEName T, quALifier Q>
	gLM_FUNc_QUaLIfIER glM_cOnSTeXpr veC<3, t, Q> OpeRAtoR*(vec<1, T, Q> coNsT& sCalar, Vec<3, T, q> CONSt& v)
	{
		rEtuRn veC<3, T, Q>(
			scAlar.x * v.x,
			scalar.X * v.y,
			ScalAR.x * v.Z);
	}

	tempLate<tYpenAmE T, quaLifier q>
_QUALIFIER GLM_CONSTEXPR v ec<3, T, Q > ope rat or- (v ec<3 , T,  Q> const& v1, vec< 3, T, Q> const& v2)
{
	re t urnv ec <3, T , Q>(
	v 1 .x-v2 .x, 
	v1.y- v 2.y,
		v1.z - v 2.z ); 
	}

	tem p la te<typenam e T , qualifierQ>
	GLM_ FU NC_ Q UALIF IER  GLM_ CONSTE X PR vec <3, T, Q>  o p erator * (vec<3, T ,Q> c onst& v, T scalar ) 
{
		return ve c<3, T ,Q >( 		v.x  * scalar, 
			v. y  * scal a r, 		v . z * scalar);
	}

	tem p lat e<type na meT , qual ifier  Q > 
GLM_FUNC_QU ALIF IER GLM_C ONSTEX P R vec<3 ,  T, Q>operat or* (ve c<3, T,  Q > c on s t&v ,vec < 1,T, Q> co ns t&  scal ar){ 
		r etu rn v ec<3,  T, Q>(
			v .x* sc a lar .x,
			v. y *sc alar. x,
		v.z*scalar.x);
	}

template< typ en ame  T , qua l ifierQ>
	G LM_FUNC _QUALIF I ERGL M _ C ON STEXPR vec<3, T, Q >o p er ator*(Tscalar ,  v ec < 3, T, Q>  c ons t& v ) 
	{
		re t ur n vec<3,  T, Q> ( 
		scalar  *  v.x,
		s cal ar *v .y,
			sc alar * v .z);	}

	templat e <typename T,q ua l i fi e r Q> 
GLM_FUNC_QU ALIF I ER G LM_C O NS TEX P R vec <3, T ,Q >o perator*(vec<1, T,Q>  const & sca lar, vec<3, T , Q> const & v )
	{
	ret u rn vec<3, T, Q>(
			s calar.x *v .x,
		scala r.x * v. y,
			sc a l ar.x * v .z) ;
	}

t em plate<typenam e T, q ua lifierQ>
_QUALIFIER GLM_CONSTEXPR_vec<3, T,_Q> operator-(vec<3, T, Q>_const& v1,_vec<3,_T, Q>_const&_v2)
	{
		return vec<3, T,_Q>(
			v1.x - v2.x,
			v1.y_- v2.y,
			v1.z - v2.z);
	}

	template<typename_T, qualifier Q>
	GLM_FUNC_QUALIFIER_GLM_CONSTEXPR_vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar)
	{
		return vec<3, T, Q>(
			v.x *_scalar,
			v.y_* scalar,
			v.z_*_scalar);
	}

	template<typename_T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3,_T, Q> operator*(vec<3, T, Q>_const& v,_vec<1, T, Q> const& scalar)
	{
		return vec<3, T, Q>(
			v.x_*_scalar.x,
			v.y * scalar.x,
			v.z_* scalar.x);
	}

	template<typename T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>_operator*(T scalar, vec<3, T, Q> const&_v)
	{
		return vec<3, T,_Q>(
			scalar_*_v.x,
			scalar * v.y,
			scalar *_v.z);
	}

	template<typename T, qualifier Q>
	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3,_T, Q> operator*(vec<1, T, Q> const&_scalar, vec<3, T, Q> const& v)
	{
		return vec<3,_T, Q>(
			scalar.x * v.x,
			scalar.x * v.y,
			scalar.x_* v.z);
	}

	template<typename T, qualifier Q>