diff --git a/glm/gtx/io.inl b/glm/gtx/io.inl
index 08c14562..5556e0cc 100644
--- a/glm/gtx/io.inl
+++ b/glm/gtx/io.inl
@@ -38,306 +38,309 @@
 namespace glm{
 namespace io
 {
-    template <typename CTy>
-    /* explicit */ GLM_FUNC_QUALIFIER
-    format_punct<CTy>::format_punct(size_t a)
-      : std::locale::facet(a),
-        formatted         (true),
-        precision         (3),
-        width             (1 + 4 + 1 + precision),
-        separator         (','),
-        delim_left        ('['),
-        delim_right       (']'),
-        space             (' '),
-        newline           ('\n'),
-        order             (column_major)
-    {}
+	template <typename CTy>
+	GLM_FUNC_QUALIFIER format_punct<CTy>::format_punct(size_t a)
+		: std::locale::facet(a)
+		, formatted(true)
+		, precision(3)
+		, width(1 + 4 + 1 + precision)
+		, separator(',')
+		, delim_left('[')
+		, delim_right(']')
+		, space(' ')
+		, newline('\n')
+		, order(column_major)
+	{}
 
-    template <typename CTy>
-    /* explicit */ GLM_FUNC_QUALIFIER
-    format_punct<CTy>::format_punct(format_punct const& a)
-      : std::locale::facet(0),
-        formatted         (a.formatted),
-        precision         (a.precision),
-        width             (a.width),
-        separator         (a.separator),
-        delim_left        (a.delim_left),
-        delim_right       (a.delim_right),
-        space             (a.space),
-        newline           (a.newline),
-        order             (a.order)
-    {}
+	template <typename CTy>
+	GLM_FUNC_QUALIFIER format_punct<CTy>::format_punct(format_punct const& a)
+		: std::locale::facet(0)
+		, formatted(a.formatted)
+		, precision(a.precision)
+		, width(a.width)
+		, separator(a.separator)
+		, delim_left(a.delim_left)
+		, delim_right(a.delim_right)
+		, space(a.space)
+		, newline(a.newline)
+		, order(a.order)
+	{}
 
-    template <typename CTy> std::locale::id format_punct<CTy>::id;
+	template <typename CTy> std::locale::id format_punct<CTy>::id;
 
-    template <typename CTy, typename CTr>
-    /* explicit */ GLM_FUNC_QUALIFIER basic_state_saver<CTy,CTr>::basic_state_saver(std::basic_ios<CTy,CTr>& a)
-      : state_    (a),
-        flags_    (a.flags()),
-        precision_(a.precision()),
-        width_    (a.width()),
-        fill_     (a.fill()),
-        locale_   (a.getloc())
-    {}
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER basic_state_saver<CTy, CTr>::basic_state_saver(std::basic_ios<CTy, CTr>& a)
+		: state_(a)
+		, flags_(a.flags())
+		, precision_(a.precision())
+		, width_(a.width())
+		, fill_(a.fill())
+		, locale_(a.getloc())
+	{}
 
-    template <typename CTy, typename CTr>
-    GLM_FUNC_QUALIFIER basic_state_saver<CTy,CTr>::~basic_state_saver()
-    {
-      state_.imbue(locale_);
-      state_.fill(fill_);
-      state_.width(width_);
-      state_.precision(precision_);
-      state_.flags(flags_);
-    }
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER basic_state_saver<CTy, CTr>::~basic_state_saver()
+	{
+		state_.imbue(locale_);
+		state_.fill(fill_);
+		state_.width(width_);
+		state_.precision(precision_);
+		state_.flags(flags_);
+	}
 
-    template <typename CTy, typename CTr>
-    /* explicit */ GLM_FUNC_QUALIFIER basic_format_saver<CTy,CTr>::basic_format_saver(std::basic_ios<CTy,CTr>& a)
-      : bss_(a)
-    {
-      a.imbue(std::locale(a.getloc(), new format_punct<CTy>(get_facet<format_punct<CTy> >(a))));
-    }
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER basic_format_saver<CTy, CTr>::basic_format_saver(std::basic_ios<CTy, CTr>& a)
+		: bss_(a)
+	{
+		a.imbue(std::locale(a.getloc(), new format_punct<CTy>(get_facet<format_punct<CTy> >(a))));
+	}
 
-    template <typename CTy, typename CTr>
-    GLM_FUNC_QUALIFIER
-    basic_format_saver<CTy,CTr>::~basic_format_saver()
-    {}
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER
+	basic_format_saver<CTy, CTr>::~basic_format_saver()
+	{}
 
-    /* explicit */ GLM_FUNC_QUALIFIER precision::precision(unsigned a)
-      : value(a)
-    {}
+	GLM_FUNC_QUALIFIER precision::precision(unsigned a)
+		: value(a)
+	{}
 
-    /* explicit */ GLM_FUNC_QUALIFIER width::width(unsigned a)
-      : value(a)
-    {}
+	GLM_FUNC_QUALIFIER width::width(unsigned a)
+		: value(a)
+	{}
 
-    template <typename CTy>
-    /* explicit */ GLM_FUNC_QUALIFIER delimeter<CTy>::delimeter(CTy a, CTy b, CTy c)
-      : value()
-    {
-      value[0] = a;
-      value[1] = b;
-      value[2] = c;
-    }
+	template <typename CTy>
+	GLM_FUNC_QUALIFIER delimeter<CTy>::delimeter(CTy a, CTy b, CTy c)
+		: value()
+	{
+		value[0] = a;
+		value[1] = b;
+		value[2] = c;
+	}
 
-    /* explicit */ GLM_FUNC_QUALIFIER order::order(order_type a)
-      : value(a)
-    {}
+	GLM_FUNC_QUALIFIER order::order(order_type a)
+		: value(a)
+	{}
 
-    template <typename FTy, typename CTy, typename CTr>
-    GLM_FUNC_QUALIFIER FTy const& get_facet(std::basic_ios<CTy,CTr>& ios)
-    {
-      if (!std::has_facet<FTy>(ios.getloc())) {
-        ios.imbue(std::locale(ios.getloc(), new FTy));
-      }
+	template <typename FTy, typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER FTy const& get_facet(std::basic_ios<CTy, CTr>& ios)
+	{
+		if(!std::has_facet<FTy>(ios.getloc()))
+			ios.imbue(std::locale(ios.getloc(), new FTy));
 
-      return std::use_facet<FTy>(ios.getloc());
-    }
+		return std::use_facet<FTy>(ios.getloc());
+	}
 
-    template <typename CTy, typename CTr>
-    GLM_FUNC_QUALIFIER std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>& ios)
-    {
-      const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = true;
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ios<CTy, CTr>& formatted(std::basic_ios<CTy, CTr>& ios)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = true;
+		return ios;
+	}
 
-      return ios;
-    }
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ios<CTy, CTr>& unformatted(std::basic_ios<CTy, CTr>& ios)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = false;
+		return ios;
+	}
 
-    template <typename CTy, typename CTr>
-    GLM_FUNC_QUALIFIER std::basic_ios<CTy,CTr>& unformatted(std::basic_ios<CTy,CTr>& ios)
-    {
-      const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = false;
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, precision const& a)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).precision = a.value;
+		return os;
+	}
 
-      return ios;
-    }
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, width const& a)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).width = a.value;
+		return os;
+	}
 
-    template <typename CTy, typename CTr>
-    GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, precision const& a)
-    {
-      const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).precision = a.value;
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, delimeter<CTy> const& a)
+	{
+		format_punct<CTy> & fmt(const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)));
 
-      return os;
-    }
+		fmt.delim_left  = a.value[0];
+		fmt.delim_right = a.value[1];
+		fmt.separator   = a.value[2];
 
-    template <typename CTy, typename CTr>
-    GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, width const& a)
-    {
-      const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).width = a.value;
+		return os;
+	}
 
-      return os;
-    }
+	template <typename CTy, typename CTr>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, order const& a)
+	{
+		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).order = a.value;
+		return os;
+	}
+} // namespace io
 
-    template <typename CTy, typename CTr>
-    GLM_FUNC_QUALIFIER  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, delimeter<CTy> const& a)
-    {
-      format_punct<CTy> & fmt(const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)));
+namespace detail
+{
+	template <typename CTy, typename CTr, template <typename, precision> class V, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>&
+	print_vector_on(std::basic_ostream<CTy, CTr>& os, V<T,P> const& a)
+	{
+		typename std::basic_ostream<CTy, CTr>::sentry const cerberus(os);
 
-      fmt.delim_left  = a.value[0];
-      fmt.delim_right = a.value[1];
-      fmt.separator   = a.value[2];
+		if(cerberus)
+		{
+			io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
 
-      return os;
-    }
+			length_t const& components(type<V, T, P>::components);
 
-    template <typename CTy, typename CTr>
-    GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, order const& a)
-    {
-      const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).order = a.value;
+			if(fmt.formatted)
+			{
+				io::basic_state_saver<CTy> const bss(os);
 
-      return os;
-    }
-  } // namespace io
+				os << std::fixed << std::right << std::setprecision(fmt.precision) << std::setfill(fmt.space) << fmt.delim_left;
 
-  namespace detail {
+				for(length_t i(0); i < components; ++i)
+				{
+					os << std::setw(fmt.width) << a[i];
+					if(components-1 != i)
+						os << fmt.separator;
+				}
 
-    template <typename CTy, typename CTr, template <typename, precision> class V, typename T, precision P>
-    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
-    print_vector_on(std::basic_ostream<CTy,CTr>& os, V<T,P> const& a)
-    {
-      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+				os << fmt.delim_right;
+			}
+			else
+			{
+				for(length_t i(0); i < components; ++i)
+				{
+					os << a[i];
 
-      if(cerberus)
-        {
-          io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
+					if(components-1 != i)
+						os << fmt.space;
+				}
+			}
+		}
 
-          length_t const& components(type<V, T, P>::components);
-          
-          if(fmt.formatted)
-            {
-              io::basic_state_saver<CTy> const bss(os);
-
-              os << std::fixed
-                 << std::right
-                 << std::setprecision(fmt.precision)
-                 << std::setfill(fmt.space)
-                 << fmt.delim_left;
-
-              for (length_t i(0); i < components; ++i) {
-                os << std::setw(fmt.width) << a[i];
-
-                if (components-1 != i) { os << fmt.separator; }
-              }
-          
-              os << fmt.delim_right;
-            }
-          else
-            {
-              for (length_t i(0); i < components; ++i) {
-                os << a[i];
-
-                if (components-1 != i) { os << fmt.space; }
-              }
-            }
-        }
-
-      return os;
-    }
-     
-  }
+		return os;
+	}
+}//namespace detail
 
 	template <typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tquat<T,P> const& a)
 	{
-    return detail::print_vector_on(os, a);
+		return detail::print_vector_on(os, a);
 	}
 
 	template <typename CTy, typename CTr, typename T, precision P>
-  GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tvec1<T,P> const& a)
-  {
-    return detail::print_vector_on(os, a);
-  }
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tvec1<T,P> const& a)
+	{
+		return detail::print_vector_on(os, a);
+	}
 
 	template <typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tvec2<T,P> const& a)
 	{
-    return detail::print_vector_on(os, a);
+		return detail::print_vector_on(os, a);
 	}
 
 	template <typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tvec3<T,P> const& a)
 	{
-    return detail::print_vector_on(os, a);
+		return detail::print_vector_on(os, a);
 	}
-  
+
 	template <typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tvec4<T,P> const& a)
 	{
-    return detail::print_vector_on(os, a);
+		return detail::print_vector_on(os, a);
 	}
 
-  namespace detail {
+namespace detail
+{
+	template <typename CTy, typename CTr, template <typename, precision> class M, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>&
+	print_matrix_on(std::basic_ostream<CTy, CTr>& os, M<T,P> const& a)
+	{
+		typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
 
-    template <typename CTy, typename CTr, template <typename, precision> class M, typename T, precision P>
-    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
-    print_matrix_on(std::basic_ostream<CTy,CTr>& os, M<T,P> const& a)
-    {
-      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+		if(cerberus)
+		{
+			io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
 
-      if(cerberus)
-        {
-          io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
+			length_t const& cols(type<M, T, P>::cols);
+			length_t const& rows(type<M, T, P>::rows);
 
-          length_t const& cols(type<M, T, P>::cols);
-          length_t const& rows(type<M, T, P>::rows);
-          
-          if(fmt.formatted) {
-            os << fmt.newline
-               << fmt.delim_left;
-            
-            switch (fmt.order) {
-            case io::column_major:
-              {
-                for (length_t i(0); i < rows; ++i) {
-                  if (0 != i) { os << fmt.space; }
+			if(fmt.formatted)
+			{
+				os << fmt.newline << fmt.delim_left;
 
-                  os << row(a, i);
+				switch(fmt.order)
+				{
+					case io::column_major:
+					{
+						for(length_t i(0); i < rows; ++i)
+						{
+							if (0 != i)
+								os << fmt.space;
 
-                  if (rows-1 != i) { os << fmt.newline; }
-                }
-              }
-              break;
+							os << row(a, i);
 
-            case io::row_major:
-              {
-                for (length_t i(0); i < cols; ++i) {
-                  if (0 != i) { os << fmt.space; }
-                  
-                  os << column(a, i);
+							if(rows-1 != i)
+								os << fmt.newline;
+						}
+					}
+					break;
 
-                  if (cols-1 != i) { os << fmt.newline; }
-                }
-              }
-              break;
-            }
+					case io::row_major:
+					{
+						for(length_t i(0); i < cols; ++i)
+						{
+							if(0 != i)
+								os << fmt.space;
 
-            os << fmt.delim_right;
-          } else {
-            switch (fmt.order) {
-            case io::column_major:
-              {
-                for (length_t i(0); i < cols; ++i) {
-                  os << column(a, i);
+							os << column(a, i);
 
-                  if (cols-1 != i) { os << fmt.space; }
-                }
-              }
-              break;
+							if(cols-1 != i)
+								os << fmt.newline;
+						}
+					}
+					break;
+				}
 
-            case io::row_major:
-              {
-                for (length_t i(0); i < rows; ++i) {
-                  os << row(a, i);
+				os << fmt.delim_right;
+			}
+			else
+			{
+				switch (fmt.order)
+				{
+					case io::column_major:
+					{
+						for(length_t i(0); i < cols; ++i)
+						{
+							os << column(a, i);
 
-                  if (rows-1 != i) { os << fmt.space; }
-                }
-              }
-              break;
-            }
-          }
-        }
-      
-      return os;
-    }
-    
-  }
+							if(cols - 1 != i)
+								os << fmt.space;
+						}
+					}
+					break;
+
+					case io::row_major:
+					{
+						for (length_t i(0); i < rows; ++i)
+						{
+							os << row(a, i);
+
+							if (rows-1 != i)
+								os << fmt.space;
+						}
+					}
+					break;
+				}
+			}
+		}
+
+		return os;
+	}
+}//namespace detail
 
 	template <typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x2<T,P> const& a)
@@ -393,74 +396,76 @@ namespace io
 		return detail::print_matrix_on(os, a);
 	}
 
-  namespace detail {
-
-    template <typename CTy, typename CTr, template <typename, precision> class M, typename T, precision P>
-    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
-    print_matrix_pair_on(std::basic_ostream<CTy,CTr>& os, std::pair<M<T,P> const, M<T,P> const> const& a)
-    {
-      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
-
-      if(cerberus)
-      {
-        io::format_punct<CTy> const& fmt(io::get_facet<io::format_punct<CTy> >(os));
-        M<T,P> const&                ml(a.first);
-        M<T,P> const&                mr(a.second);
-        length_t const&              cols(type<M, T, P>::cols);
-        length_t const&              rows(type<M, T, P>::rows);
-          
-        if(fmt.formatted) {
-          os << fmt.newline
-             << fmt.delim_left;
-            
-          switch (fmt.order) {
-          case io::column_major:
-            {
-              for (length_t i(0); i < rows; ++i) {
-                if (0 != i) { os << fmt.space; }
-
-                os << row(ml, i)
-                   << ((rows-1 != i) ? fmt.space : fmt.delim_right)
-                   << fmt.space
-                   << ((0 != i) ? fmt.space : fmt.delim_left)
-                   << row(mr, i);
-
-                if (rows-1 != i) { os << fmt.newline; }
-              }
-            }
-            break;
-
-          case io::row_major:
-            {
-              for (length_t i(0); i < cols; ++i) {
-                if (0 != i) { os << fmt.space; }
-
-                os << column(ml, i)
-                   << ((cols-1 != i) ? fmt.space : fmt.delim_right)
-                   << fmt.space
-                   << ((0 != i) ? fmt.space : fmt.delim_left)
-                   << column(mr, i);
-
-                if (cols-1 != i) { os << fmt.newline; }
-              }
-            }
-            break;
-          }
-
-          os << fmt.delim_right;
-        } else {
-          os << ml << fmt.space << mr;
-        }
-      }
-
-      return os;
-    }
-  }
-  
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr> & os,
-                                                             std::pair<tmat4x4<T,P> const, tmat4x4<T,P> const> const& a)
+namespace detail
+{
+	template <typename CTy, typename CTr, template <typename, precision> class M, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>&
+	print_matrix_pair_on(std::basic_ostream<CTy, CTr>& os, std::pair<M<T, P> const, M<T, P> const> const& a)
 	{
-    return detail::print_matrix_pair_on(os, a);
+		typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+		if(cerberus)
+		{
+			io::format_punct<CTy> const& fmt(io::get_facet<io::format_punct<CTy> >(os));
+			M<T,P> const& ml(a.first);
+			M<T,P> const& mr(a.second);
+			length_t const& cols(type<M, T, P>::cols);
+			length_t const& rows(type<M, T, P>::rows);
+
+			if(fmt.formatted)
+			{
+				os << fmt.newline << fmt.delim_left;
+
+				switch(fmt.order)
+				{
+					case io::column_major:
+					{
+						for(length_t i(0); i < rows; ++i)
+						{
+							if(0 != i)
+								os << fmt.space;
+
+							os << row(ml, i) << ((rows-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << row(mr, i);
+
+							if(rows-1 != i)
+								os << fmt.newline;
+						}
+					}
+					break;
+					case io::row_major:
+					{
+						for(length_t i(0); i < cols; ++i)
+						{
+							if(0 != i)
+								os << fmt.space;
+
+								os << column(ml, i) << ((cols-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << column(mr, i);
+
+							if(cols-1 != i)
+								os << fmt.newline;
+						}
+					}
+					break;
+				}
+
+				os << fmt.delim_right;
+			}
+			else
+			{
+				os << ml << fmt.space << mr;
+			}
+		}
+
+		return os;
+	}
+}//namespace detail
+
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(
+		std::basic_ostream<CTy, CTr> & os,
+		std::pair<tmat4x4<T, P> const,
+		tmat4x4<T, P> const> const& a)
+	{
+		return detail::print_matrix_pair_on(os, a);
 	}
 }//namespace glm