diff --git a/Utilities/BEType.h b/Utilities/BEType.h
index 38d01a9952..b75b5291d3 100644
--- a/Utilities/BEType.h
+++ b/Utilities/BEType.h
@@ -556,52 +556,49 @@ template<u64 _value> struct const_se_t<u64, _value, 8>
 		((_value << 56) & 0xff00000000000000);
 };
 
-template<typename T, size_t size = sizeof(T)>
-struct be_storage_t
+template<typename T, size_t size = sizeof(T)> struct be_storage
 {
-	static_assert(!size, "Bad be_storage_t type");
+	static_assert(!size, "Bad be_storage_t<> type");
 };
 
-template<typename T>
-struct be_storage_t<T, 1>
-{
-	typedef u8 type;
-};
-
-template<typename T>
-struct be_storage_t<T, 2>
+template<typename T> struct be_storage<T, 2>
 {
 	typedef u16 type;
 };
 
-template<typename T>
-struct be_storage_t<T, 4>
+template<typename T> struct be_storage<T, 4>
 {
 	typedef u32 type;
 };
 
-template<typename T>
-struct be_storage_t<T, 8>
+template<typename T> struct be_storage<T, 8>
 {
 	typedef u64 type;
 };
 
-template<typename T>
-struct be_storage_t<T, 16>
+template<typename T> struct be_storage<T, 16>
 {
 	typedef u128 type;
 };
 
-template<typename T, typename T2 = T>
-class be_t
-{
-public:
-	typedef typename std::remove_cv<T>::type type;
-	typedef typename be_storage_t<T2>::type stype;
+template<typename T> using be_storage_t = typename be_storage<T>::type;
+
+template<typename T>
+struct be_t
+{
+	using type = std::remove_cv_t<T>;
+	using stype = be_storage_t<type>;
 
-private:
 	stype m_data;
 
+	static_assert(!std::is_class<type>::value, "be_t<> error: invalid type (class or structure)");
+	static_assert(!std::is_union<type>::value || std::is_same<type, u128>::value, "be_t<> error: invalid type (union)");
+	static_assert(!std::is_pointer<type>::value, "be_t<> error: invalid type (pointer)");
+	static_assert(!std::is_reference<type>::value, "be_t<> error: invalid type (reference)");
+	static_assert(!std::is_array<type>::value, "be_t<> error: invalid type (array)");
+	static_assert(__alignof(type) == __alignof(stype), "be_t<> error: unexpected alignment");
+
+private:
 	template<typename Tto, typename Tfrom, int mode>
 	struct _convert
 	{
@@ -639,7 +636,7 @@ private:
 
 	type ToLE() const
 	{
-		return se_t<type, sizeof(T2)>::from_be(m_data);
+		return se_t<type, sizeof(stype)>::from_be(m_data);
 	}
 
 	void FromBE(const stype& value)
@@ -649,13 +646,12 @@ private:
 
 	void FromLE(const type& value)
 	{
-		m_data = se_t<type, sizeof(T2)>::to_be(value);
+		m_data = se_t<type, sizeof(stype)>::to_be(value);
 	}
 
-public:
 	static be_t MakeFromLE(const type& value)
 	{
-		stype data = se_t<type, sizeof(T2)>::to_be(value);
+		stype data = se_t<type, sizeof(stype)>::to_be(value);
 		return (be_t&)data;
 	}
 
@@ -664,6 +660,7 @@ public:
 		return (be_t&)value;
 	}
 
+public:
 	//make be_t from current machine byte ordering
 	static be_t make(const type& value)
 	{
@@ -689,37 +686,44 @@ public:
 		return ToBE();
 	}
 	
-	be_t& operator = (const be_t& value) = default;
+	be_t& operator =(const be_t& value) = default;
 
-	be_t& operator = (const type& value)
+	template<typename CT> std::enable_if_t<std::is_assignable<type&, CT>::value, be_t&> operator =(const CT& value)
 	{
-		m_data = se_t<type, sizeof(T2)>::to_be(value);
+		m_data = se_t<type, sizeof(stype)>::to_be(value);
 
 		return *this;
 	}
 
+	//template<typename CT> operator std::enable_if_t<std::is_convertible<type, CT>::value, CT>() const
+	//{
+	//	return value();
+	//}
+
 	operator type() const
 	{
 		return value();
 	}
 
-	template<typename T1>
-	operator const be_t<T1>() const
+	// conversion to another be_t type
+	template<typename T1> operator be_t<T1>() const
 	{
 		return be_t<T1>::make(value());
+
+		// TODO (complicated cases like int-float conversions are not handled correctly)
 		//return _convert<T1, T, ((sizeof(T1) > sizeof(T)) ? 1 : (sizeof(T1) < sizeof(T) ? 2 : 0))>::func(m_data);
 	}
 
-	template<typename T1> be_t& operator += (T1 right) { return *this = T(*this) + right; }
-	template<typename T1> be_t& operator -= (T1 right) { return *this = T(*this) - right; }
-	template<typename T1> be_t& operator *= (T1 right) { return *this = T(*this) * right; }
-	template<typename T1> be_t& operator /= (T1 right) { return *this = T(*this) / right; }
-	template<typename T1> be_t& operator %= (T1 right) { return *this = T(*this) % right; }
-	template<typename T1> be_t& operator &= (T1 right) { return *this = T(*this) & right; }
-	template<typename T1> be_t& operator |= (T1 right) { return *this = T(*this) | right; }
-	template<typename T1> be_t& operator ^= (T1 right) { return *this = T(*this) ^ right; }
-	template<typename T1> be_t& operator <<= (T1 right) { return *this = T(*this) << right; }
-	template<typename T1> be_t& operator >>= (T1 right) { return *this = T(*this) >> right; }
+	template<typename T1> be_t& operator += (T1 right) { return *this = value() + right; }
+	template<typename T1> be_t& operator -= (T1 right) { return *this = value() - right; }
+	template<typename T1> be_t& operator *= (T1 right) { return *this = value() * right; }
+	template<typename T1> be_t& operator /= (T1 right) { return *this = value() / right; }
+	template<typename T1> be_t& operator %= (T1 right) { return *this = value() % right; }
+	template<typename T1> be_t& operator &= (T1 right) { return *this = value() & right; }
+	template<typename T1> be_t& operator |= (T1 right) { return *this = value() | right; }
+	template<typename T1> be_t& operator ^= (T1 right) { return *this = value() ^ right; }
+	template<typename T1> be_t& operator <<= (T1 right) { return *this = value() << right; }
+	template<typename T1> be_t& operator >>= (T1 right) { return *this = value() >> right; }
 
 	template<typename T1> be_t& operator += (const be_t<T1>& right) { return *this = ToLE() + right.ToLE(); }
 	template<typename T1> be_t& operator -= (const be_t<T1>& right) { return *this = ToLE() - right.ToLE(); }
@@ -730,9 +734,9 @@ public:
 	template<typename T1> be_t& operator |= (const be_t<T1>& right) { return *this = ToBE() | right.ToBE(); }
 	template<typename T1> be_t& operator ^= (const be_t<T1>& right) { return *this = ToBE() ^ right.ToBE(); }
 
-	template<typename T1> be_t operator & (const be_t<T1>& right) const { be_t<T> res; res.FromBE(ToBE() & right.ToBE()); return res; }
-	template<typename T1> be_t operator | (const be_t<T1>& right) const { be_t<T> res; res.FromBE(ToBE() | right.ToBE()); return res; }
-	template<typename T1> be_t operator ^ (const be_t<T1>& right) const { be_t<T> res; res.FromBE(ToBE() ^ right.ToBE()); return res; }
+	template<typename T1> be_t operator & (const be_t<T1>& right) const { be_t res; res.FromBE(ToBE() & right.ToBE()); return res; }
+	template<typename T1> be_t operator | (const be_t<T1>& right) const { be_t res; res.FromBE(ToBE() | right.ToBE()); return res; }
+	template<typename T1> be_t operator ^ (const be_t<T1>& right) const { be_t res; res.FromBE(ToBE() ^ right.ToBE()); return res; }
 
 	template<typename T1> bool operator == (T1 right) const { return (T1)ToLE() == right; }
 	template<typename T1> bool operator != (T1 right) const { return !(*this == right); }
@@ -754,114 +758,40 @@ public:
 	be_t& operator-- () { *this -= 1; return *this; }
 };
 
-template<typename T, typename T2 = T>
-struct is_be_t : public std::integral_constant<bool, false> {};
-
-template<typename T, typename T2>
-struct is_be_t<be_t<T, T2>, T2> : public std::integral_constant<bool, true> {};
-
-template<typename T, typename T2 = T>
-struct remove_be_t
+template<typename T> struct is_be_t : public std::integral_constant<bool, false>
 {
-	typedef T type;
 };
 
-template<typename T, typename T2>
-struct remove_be_t<be_t<T, T2>>
+template<typename T> struct is_be_t<be_t<T>> : public std::integral_constant<bool, true>
 {
-	typedef T type;
 };
 
-template<typename T, typename T2 = T>
-class to_be_t
+// to_be_t helper struct
+template<typename T> struct to_be
 {
-	template<typename TT, typename TT2, bool is_need_swap>
-	struct _be_type_selector
-	{
-		typedef TT type;
-	};
-
-	template<typename TT, typename TT2>
-	struct _be_type_selector<TT, TT2, true>
-	{
-		typedef be_t<TT, TT2> type;
-	};
-
-public:
-	//true if need swap endianes for be
-	static const bool value = std::is_arithmetic<T>::value || std::is_enum<T>::value;
-
-	//be_t<T, size> if need swap endianes, T otherwise
-	typedef typename _be_type_selector< T, T2, value >::type type;
-
-	typedef typename _be_type_selector< T, T2, !is_be_t<T, T2>::value >::type forced_type;
+	using type = std::conditional_t<std::is_arithmetic<T>::value || std::is_enum<T>::value, be_t<T>, T>;
 };
 
-template<typename T, typename T2>
-class to_be_t<T, const T2>
+// be_t<T> if possible, T otherwise
+template<typename T> using to_be_t = typename to_be<T>::type;
+
+template<typename T> struct to_be<const T>
 {
-public:
-	static const bool value = to_be_t<T, T2>::value;
-	typedef const typename to_be_t<T, T2>::type type;
-	typedef const typename to_be_t<T, T2>::forced_type forced_type;
+	// move const qualifier
+	using type = const to_be_t<std::remove_const_t<T>>;
 };
 
-template<typename T>
-class to_be_t<T, void>
+template<typename T> struct to_be<volatile T>
 {
-public:
-	static const bool value = false;
-	typedef void type;
-	typedef void forced_type;
+	// move volatile qualifier
+	using type = volatile to_be_t<std::remove_volatile_t<T>>;
 };
 
-template<typename T>
-class to_be_t<T, u8>
-{
-public:
-	static const bool value = false;
-	typedef u8 type;
-	typedef u8 forced_type;
-};
-
-template<typename T>
-class to_be_t<T, s8>
-{
-public:
-	static const bool value = false;
-	typedef s8 type;
-	typedef s8 forced_type;
-};
-
-template<typename T>
-class to_be_t<T, char>
-{
-public:
-	static const bool value = false;
-	typedef char type;
-	typedef char forced_type;
-};
-
-template<typename T>
-class to_be_t<T, bool>
-{
-public:
-	static const bool value = false;
-	typedef bool type;
-	typedef bool forced_type;
-};
-
-template<typename T, typename T2 = T>
-struct invert_be_t
-{
-	typedef typename to_be_t<T, T2>::type type;
-};
-
-template<typename T, typename T2>
-struct invert_be_t<be_t<T, T2>>
-{
-	typedef T type;
-};
+template<> struct to_be<void> { using type = void; };
+template<> struct to_be<bool> { using type = bool; };
+template<> struct to_be<char> { using type = char; };
+template<> struct to_be<u8> { using type = u8; };
+template<> struct to_be<s8> { using type = s8; };
 
 template<typename T, typename T1, T1 value> struct _se : public const_se_t<T, value> {};
 template<typename T, typename T1, T1 value> struct _se<be_t<T>, T1, value> : public const_se_t<T, value> {};
@@ -880,28 +810,28 @@ struct convert_le_be_t
 	}
 };
 
-template<typename Tt, typename Tt1, typename Tfrom>
-struct convert_le_be_t<be_t<Tt, Tt1>, Tfrom>
+template<typename Tt, typename Tfrom>
+struct convert_le_be_t<be_t<Tt>, Tfrom>
 {
-	static be_t<Tt, Tt1> func(Tfrom value)
+	static be_t<Tt> func(Tfrom value)
 	{
-		return be_t<Tt, Tt1>::make(value);
+		return be_t<Tt>::make(value);
 	}
 };
 
-template<typename Tt, typename Tt1, typename Tf, typename Tf1>
-struct convert_le_be_t<be_t<Tt, Tt1>, be_t<Tf, Tf1>>
+template<typename Tt, typename Tf>
+struct convert_le_be_t<be_t<Tt>, be_t<Tf>>
 {
-	static be_t<Tt, Tt1> func(be_t<Tf, Tf1> value)
+	static be_t<Tt> func(be_t<Tf> value)
 	{
 		return value;
 	}
 };
 
-template<typename Tto, typename Tf, typename Tf1>
-struct convert_le_be_t<Tto, be_t<Tf, Tf1>>
+template<typename Tto, typename Tf>
+struct convert_le_be_t<Tto, be_t<Tf>>
 {
-	static Tto func(be_t<Tf, Tf1> value)
+	static Tto func(be_t<Tf> value)
 	{
 		return value.value();
 	}
@@ -919,6 +849,85 @@ force_inline void convert_le_be(Tto& dst, Tfrom src)
 	dst = convert_le_be_t<Tto, Tfrom>::func(src);
 }
 
-template<typename T> using le_t = T;
+template<typename T> struct le_t
+{
+	using type = std::remove_cv_t<T>;
+	using stype = be_storage_t<type>;
 
-template<typename T> struct to_le_t { using type = T; };
+	stype m_data;
+
+	type value() const
+	{
+		return reinterpret_cast<const type&>(m_data);
+	}
+
+	le_t& operator =(const le_t& value) = default;
+
+	template<typename CT> std::enable_if_t<std::is_assignable<type&, CT>::value, le_t&> operator =(const CT& value)
+	{
+		m_data = reinterpret_cast<const stype&>(value);
+
+		return *this;
+	}
+
+	//template<typename CT> operator std::enable_if_t<std::is_convertible<type, CT>::value, CT>() const
+	//{
+	//	return value();
+	//}
+
+	operator type() const
+	{
+		return value();
+	}
+
+	// conversion to another le_t type
+	//template<typename T1> operator const le_t<T1>() const
+	//{
+	//	return le_t<T1>::make(value());
+	//}
+};
+
+template<typename T> struct to_le
+{
+	using type = std::conditional_t<std::is_arithmetic<T>::value || std::is_enum<T>::value, le_t<T>, T>;
+};
+
+// le_t<T> if possible, T otherwise
+template<typename T> using to_le_t = typename to_le<T>::type;
+
+template<typename T> struct to_le<const T>
+{
+	// move const qualifier
+	using type = const to_le_t<std::remove_const_t<T>>;
+};
+
+template<typename T> struct to_le<volatile T>
+{
+	// move volatile qualifier
+	using type = volatile to_le_t<std::remove_volatile_t<T>>;
+};
+
+template<> struct to_le<void> { using type = void; };
+template<> struct to_le<bool> { using type = bool; };
+template<> struct to_le<char> { using type = char; };
+template<> struct to_le<u8> { using type = u8; };
+template<> struct to_le<s8> { using type = s8; };
+
+// to_ne_t helper struct
+template<typename T> struct to_ne
+{
+	using type = T;
+};
+
+// restore native endianness for T: returns T for be_t<T> or le_t<T>, T otherwise
+template<typename T> using to_ne_t = typename to_ne<T>::type;
+
+template<typename T> struct to_ne<be_t<T>>
+{
+	using type = T;
+};
+
+template<typename T> struct to_ne<le_t<T>>
+{
+	using type = T;
+};
diff --git a/Utilities/GNU.h b/Utilities/GNU.h
index d592131297..64a45acb63 100644
--- a/Utilities/GNU.h
+++ b/Utilities/GNU.h
@@ -82,42 +82,42 @@ int clock_gettime(int foo, struct timespec *ts);
 
 #endif /* __APPLE__ */
 
-template<typename T, typename T2> static inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sync_val_compare_and_swap(volatile T* dest, T2 comp, T2 exch)
+template<typename T, typename T2> static inline std::enable_if_t<std::is_arithmetic<T>::value, T> sync_val_compare_and_swap(volatile T* dest, T2 comp, T2 exch)
 {
 	return __sync_val_compare_and_swap(dest, comp, exch);
 }
 
-template<typename T, typename T2> static inline typename std::enable_if<std::is_arithmetic<T>::value, bool>::type sync_bool_compare_and_swap(volatile T* dest, T2 comp, T2 exch)
+template<typename T, typename T2> static inline std::enable_if_t<std::is_arithmetic<T>::value, bool> sync_bool_compare_and_swap(volatile T* dest, T2 comp, T2 exch)
 {
 	return __sync_bool_compare_and_swap(dest, comp, exch);
 }
 
-template<typename T, typename T2> static inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sync_lock_test_and_set(volatile T* dest, T2 value)
+template<typename T, typename T2> static inline std::enable_if_t<std::is_arithmetic<T>::value, T> sync_lock_test_and_set(volatile T* dest, T2 value)
 {
 	return __sync_lock_test_and_set(dest, value);
 }
 
-template<typename T, typename T2> static inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sync_fetch_and_add(volatile T* dest, T2 value)
+template<typename T, typename T2> static inline std::enable_if_t<std::is_arithmetic<T>::value, T> sync_fetch_and_add(volatile T* dest, T2 value)
 {
 	return __sync_fetch_and_add(dest, value);
 }
 
-template<typename T, typename T2> static inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sync_fetch_and_sub(volatile T* dest, T2 value)
+template<typename T, typename T2> static inline std::enable_if_t<std::is_arithmetic<T>::value, T> sync_fetch_and_sub(volatile T* dest, T2 value)
 {
 	return __sync_fetch_and_sub(dest, value);
 }
 
-template<typename T, typename T2> static inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sync_fetch_and_or(volatile T* dest, T2 value)
+template<typename T, typename T2> static inline std::enable_if_t<std::is_arithmetic<T>::value, T> sync_fetch_and_or(volatile T* dest, T2 value)
 {
 	return __sync_fetch_and_or(dest, value);
 }
 
-template<typename T, typename T2> static inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sync_fetch_and_and(volatile T* dest, T2 value)
+template<typename T, typename T2> static inline std::enable_if_t<std::is_arithmetic<T>::value, T> sync_fetch_and_and(volatile T* dest, T2 value)
 {
 	return __sync_fetch_and_and(dest, value);
 }
 
-template<typename T, typename T2> static inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sync_fetch_and_xor(volatile T* dest, T2 value)
+template<typename T, typename T2> static inline std::enable_if_t<std::is_arithmetic<T>::value, T> sync_fetch_and_xor(volatile T* dest, T2 value)
 {
 	return __sync_fetch_and_xor(dest, value);
 }
diff --git a/Utilities/StrFmt.h b/Utilities/StrFmt.h
index 406446502c..4011878360 100644
--- a/Utilities/StrFmt.h
+++ b/Utilities/StrFmt.h
@@ -179,7 +179,7 @@ namespace fmt
 	template<typename T, bool is_enum = std::is_enum<T>::value>
 	struct unveil
 	{
-		typedef T result_type;
+		using result_type = T;
 
 		force_inline static result_type get_value(const T& arg)
 		{
@@ -190,7 +190,7 @@ namespace fmt
 	template<>
 	struct unveil<char*, false>
 	{
-		typedef const char* result_type;
+		using result_type = const char*;
 
 		force_inline static result_type get_value(const char* arg)
 		{
@@ -201,7 +201,7 @@ namespace fmt
 	template<size_t N>
 	struct unveil<const char[N], false>
 	{
-		typedef const char* result_type;
+		using result_type = const char*;
 
 		force_inline static result_type get_value(const char(&arg)[N])
 		{
@@ -212,7 +212,7 @@ namespace fmt
 	template<>
 	struct unveil<std::string, false>
 	{
-		typedef const char* result_type;
+		using result_type = const char*;
 
 		force_inline static result_type get_value(const std::string& arg)
 		{
@@ -223,7 +223,7 @@ namespace fmt
 	template<typename T>
 	struct unveil<T, true>
 	{
-		typedef typename std::underlying_type<T>::type result_type;
+		using result_type = std::underlying_type_t<T>;
 
 		force_inline static result_type get_value(const T& arg)
 		{
@@ -231,12 +231,12 @@ namespace fmt
 		}
 	};
 
-	template<typename T, typename T2>
-	struct unveil<be_t<T, T2>, false>
+	template<typename T>
+	struct unveil<be_t<T>, false>
 	{
-		typedef typename unveil<T>::result_type result_type;
+		using result_type = typename unveil<T>::result_type;
 
-		force_inline static result_type get_value(const be_t<T, T2>& arg)
+		force_inline static result_type get_value(const be_t<T>& arg)
 		{
 			return unveil<T>::get_value(arg.value());
 		}
diff --git a/rpcs3/Emu/ARMv7/ARMv7Context.h b/rpcs3/Emu/ARMv7/ARMv7Context.h
index dc14117845..876e55fb36 100644
--- a/rpcs3/Emu/ARMv7/ARMv7Context.h
+++ b/rpcs3/Emu/ARMv7/ARMv7Context.h
@@ -187,16 +187,14 @@ struct cast_armv7_gpr
 {
 	static_assert(is_enum, "Invalid type for cast_armv7_gpr");
 
-	typedef typename std::underlying_type<T>::type underlying_type;
-
 	force_inline static u32 to_gpr(const T& value)
 	{
-		return cast_armv7_gpr<underlying_type>::to_gpr(static_cast<underlying_type>(value));
+		return cast_armv7_gpr<std::underlying_type_t<T>>::to_gpr(static_cast<std::underlying_type_t<T>>(value));
 	}
 
 	force_inline static T from_gpr(const u32 reg)
 	{
-		return static_cast<T>(cast_armv7_gpr<underlying_type>::from_gpr(reg));
+		return static_cast<T>(cast_armv7_gpr<std::underlying_type_t<T>>::from_gpr(reg));
 	}
 };
 
diff --git a/rpcs3/Emu/ARMv7/PSVFuncList.h b/rpcs3/Emu/ARMv7/PSVFuncList.h
index fb7215a61a..9bd061b512 100644
--- a/rpcs3/Emu/ARMv7/PSVFuncList.h
+++ b/rpcs3/Emu/ARMv7/PSVFuncList.h
@@ -307,7 +307,7 @@ namespace psv_func_detail
 	template <typename RT, typename F, typename Tuple>
 	force_inline RT call(F f, Tuple && t)
 	{
-		typedef typename std::decay<Tuple>::type ttype;
+		using ttype = std::decay_t<Tuple>;
 		return psv_func_detail::call_impl<RT, F, Tuple, 0 == std::tuple_size<ttype>::value, std::tuple_size<ttype>::value>::call(f, std::forward<Tuple>(t));
 	}
 
diff --git a/rpcs3/Emu/Cell/PPUThread.h b/rpcs3/Emu/Cell/PPUThread.h
index 31d44fad14..4a5ced3483 100644
--- a/rpcs3/Emu/Cell/PPUThread.h
+++ b/rpcs3/Emu/Cell/PPUThread.h
@@ -845,16 +845,14 @@ struct cast_ppu_gpr
 {
 	static_assert(is_enum, "Invalid type for cast_ppu_gpr");
 
-	typedef typename std::underlying_type<T>::type underlying_type;
-
 	force_inline static u64 to_gpr(const T& value)
 	{
-		return cast_ppu_gpr<underlying_type>::to_gpr(static_cast<underlying_type>(value));
+		return cast_ppu_gpr<std::underlying_type_t<T>>::to_gpr(static_cast<std::underlying_type_t<T>>(value));
 	}
 
 	force_inline static T from_gpr(const u64 reg)
 	{
-		return static_cast<T>(cast_ppu_gpr<underlying_type>::from_gpr(reg));
+		return static_cast<T>(cast_ppu_gpr<std::underlying_type_t<T>>::from_gpr(reg));
 	}
 };
 
diff --git a/rpcs3/Emu/Memory/atomic.h b/rpcs3/Emu/Memory/atomic.h
index b09cf04359..fc4e430bb6 100644
--- a/rpcs3/Emu/Memory/atomic.h
+++ b/rpcs3/Emu/Memory/atomic.h
@@ -1,46 +1,41 @@
 #pragma once
 
-template<typename T, size_t size = sizeof(T)>
-struct _to_atomic_subtype
+template<typename T, size_t size = sizeof(T)> struct _to_atomic_subtype
 {
 	static_assert(size == 1 || size == 2 || size == 4 || size == 8 || size == 16, "Invalid atomic type");
 };
 
-template<typename T>
-struct _to_atomic_subtype<T, 1>
+template<typename T> struct _to_atomic_subtype<T, 1>
 {
-	using type = uint8_t;
+	using type = u8;
 };
 
-template<typename T>
-struct _to_atomic_subtype<T, 2>
+template<typename T> struct _to_atomic_subtype<T, 2>
 {
-	using type = uint16_t;
+	using type = u16;
 };
 
-template<typename T>
-struct _to_atomic_subtype<T, 4>
+template<typename T> struct _to_atomic_subtype<T, 4>
 {
-	using type = uint32_t;
+	using type = u32;
 };
 
-template<typename T>
-struct _to_atomic_subtype<T, 8>
+template<typename T> struct _to_atomic_subtype<T, 8>
 {
-	using type = uint64_t;
+	using type = u64;
 };
 
-template<typename T>
-struct _to_atomic_subtype<T, 16>
+template<typename T> struct _to_atomic_subtype<T, 16>
 {
 	using type = u128;
 };
 
-template<typename T>
-union _atomic_base
+template<typename T> using atomic_subtype_t = typename _to_atomic_subtype<T>::type;
+
+template<typename T> union _atomic_base
 {
-	using type = typename std::remove_cv<T>::type;
-	using subtype = typename _to_atomic_subtype<type, sizeof(type)>::type;
+	using type = std::remove_cv_t<T>;
+	using subtype = atomic_subtype_t<type>;
 
 	type data; // unsafe direct access
 	subtype sub_data; // unsafe direct access to substitute type
@@ -197,8 +192,8 @@ public:
 
 // Helper definitions
 
-template<typename T, typename T2 = T> using if_arithmetic_le_t = const typename std::enable_if<std::is_arithmetic<T>::value && std::is_arithmetic<T2>::value, le_t<T>>::type;
-template<typename T, typename T2 = T> using if_arithmetic_be_t = const typename std::enable_if<std::is_arithmetic<T>::value && std::is_arithmetic<T2>::value, be_t<T>>::type;
+template<typename T, typename T2 = T> using if_arithmetic_le_t = std::enable_if_t<std::is_arithmetic<T>::value && std::is_arithmetic<T2>::value, le_t<T>>;
+template<typename T, typename T2 = T> using if_arithmetic_be_t = std::enable_if_t<std::is_arithmetic<T>::value && std::is_arithmetic<T2>::value, be_t<T>>;
 
 template<typename T> inline static if_arithmetic_le_t<T> operator ++(_atomic_base<le_t<T>>& left)
 {
@@ -304,6 +299,6 @@ template<typename T, typename T2> inline static if_arithmetic_be_t<T, T2> operat
 
 template<typename T> using atomic = _atomic_base<T>; // Atomic Type with native endianness (for emulator memory)
 
-template<typename T> using atomic_be_t = _atomic_base<typename to_be_t<T>::type>; // Atomic BE Type (for PS3 virtual memory)
+template<typename T> using atomic_be_t = _atomic_base<to_be_t<T>>; // Atomic BE Type (for PS3 virtual memory)
 
-template<typename T> using atomic_le_t = _atomic_base<typename to_le_t<T>::type>; // Atomic LE Type (for PSV virtual memory)
+template<typename T> using atomic_le_t = _atomic_base<to_le_t<T>>; // Atomic LE Type (for PSV virtual memory)
diff --git a/rpcs3/Emu/Memory/vm.h b/rpcs3/Emu/Memory/vm.h
index 5413ca90b3..8dea66bff7 100644
--- a/rpcs3/Emu/Memory/vm.h
+++ b/rpcs3/Emu/Memory/vm.h
@@ -127,10 +127,10 @@ namespace vm
 		}
 	};
 
-	template<typename T, typename T2>
-	struct cast_ptr<be_t<T, T2>>
+	template<typename T>
+	struct cast_ptr<be_t<T>>
 	{
-		force_inline static u32 cast(const be_t<T, T2>& addr, const char* func)
+		force_inline static u32 cast(const be_t<T>& addr, const char* func)
 		{
 			return cast_ptr<T>::cast(addr.value(), func);
 		}
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 973aa55719..11fe0307f4 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -10,7 +10,11 @@ namespace vm
 	{
 		AT m_addr;
 
-		typedef typename std::remove_cv<T>::type type;
+		using type = T;
+
+		static_assert(!std::is_pointer<T>::value, "vm::_ptr_base<> error: invalid type (pointer)");
+		static_assert(!std::is_reference<T>::value, "vm::_ptr_base<> error: invalid type (reference)");
+
 		static const u32 address_size = sizeof(AT);
 
 		_ptr_base operator++ (int)
@@ -51,10 +55,8 @@ namespace vm
 			return *this;
 		}
 
-		_ptr_base operator + (typename	remove_be_t<AT>::type count) const { return make(m_addr + count * address_size); }
-		_ptr_base operator + (typename		to_be_t<AT>::type count) const { return make(m_addr + count * address_size); }
-		_ptr_base operator - (typename	remove_be_t<AT>::type count) const { return make(m_addr - count * address_size); }
-		_ptr_base operator - (typename		to_be_t<AT>::type count) const { return make(m_addr - count * address_size); }
+		_ptr_base operator + (to_ne_t<AT> count) const { return make(m_addr + count * address_size); }
+		_ptr_base operator - (to_ne_t<AT> count) const { return make(m_addr - count * address_size); }
 
 		force_inline bool operator <(const _ptr_base& right) const { return m_addr < right.m_addr; }
 		force_inline bool operator <=(const _ptr_base& right) const { return m_addr <= right.m_addr; }
@@ -66,23 +68,21 @@ namespace vm
 		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
 		explicit operator bool() const { return m_addr != 0; }
 
-		force_inline _ptr_base<T, lvl - 1, typename std::conditional<is_be_t<T>::value, typename to_be_t<AT>::type, AT>::type> operator *() const
+		force_inline _ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>> operator *() const
 		{
 			AT addr = convert_le_be<AT>(read64(convert_le_be<u32>(m_addr)));
-			return (_ptr_base<T, lvl - 1, typename std::conditional<is_be_t<T>::value, typename to_be_t<AT>::type, AT>::type>&)addr;
+			return (_ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>>&)addr;
 		}
 
-		force_inline _ptr_base<T, lvl - 1, typename std::conditional<is_be_t<T>::value, typename to_be_t<AT>::type, AT>::type> operator [](AT index) const
+		force_inline _ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>> operator [](AT index) const
 		{
 			AT addr = convert_le_be<AT>(read64(convert_le_be<u32>(m_addr + 8 * index)));
-			return (_ptr_base<T, lvl - 1, typename std::conditional<is_be_t<T>::value, typename to_be_t<AT>::type, AT>::type>&)addr;
+			return (_ptr_base<T, lvl - 1, std::conditional_t<is_be_t<T>::value, to_be_t<AT>, AT>>&)addr;
 		}
 
-		template<typename AT2>
-		operator _ptr_base<T, lvl, AT2>() const
+		template<typename AT2> operator _ptr_base<T, lvl, AT2>() const
 		{
-			AT2 addr = convert_le_be<AT2>(m_addr);
-			return reinterpret_cast<_ptr_base<T, lvl, AT2>&>(addr);
+			return{ convert_le_be<AT2>(m_addr) };
 		}
 		
 		AT addr() const
@@ -90,15 +90,14 @@ namespace vm
 			return m_addr;
 		}
 
-		template<typename U>
-		void set(U&& value)
+		template<typename U> void set(U&& value)
 		{
 			m_addr = convert_le_be<AT>(value);
 		}
 
-		static _ptr_base make(const AT& addr)
+		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
 		{
-			return reinterpret_cast<const _ptr_base&>(addr);
+			return{ convert_le_be<AT>(addr) };
 		}
 
 		_ptr_base& operator = (const _ptr_base& right) = default;
@@ -108,10 +107,11 @@ namespace vm
 	struct _ptr_base<T, 1, AT>
 	{
 		AT m_addr;
+
+		using type = T;
 		
 		static_assert(!std::is_pointer<T>::value, "vm::_ptr_base<> error: invalid type (pointer)");
 		static_assert(!std::is_reference<T>::value, "vm::_ptr_base<> error: invalid type (reference)");
-		typedef typename std::remove_cv<T>::type type;
 
 		force_inline static const u32 data_size()
 		{
@@ -161,22 +161,15 @@ namespace vm
 			return *this;
 		}
 
-		_ptr_base operator + (typename	remove_be_t<AT>::type count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) + count * convert_le_be<decltype(count)>(data_size()))); }
-		_ptr_base operator + (typename		to_be_t<AT>::type count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) + count * convert_le_be<decltype(count)>(data_size()))); }
-		_ptr_base operator - (typename	remove_be_t<AT>::type count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) - count * convert_le_be<decltype(count)>(data_size()))); }
-		_ptr_base operator - (typename		to_be_t<AT>::type count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) - count * convert_le_be<decltype(count)>(data_size()))); }
+		_ptr_base operator + (to_ne_t<AT> count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) +count * convert_le_be<decltype(count)>(data_size()))); }
+		_ptr_base operator - (to_ne_t<AT> count) const { return make(convert_le_be<AT>(convert_le_be<decltype(count)>(m_addr) -count * convert_le_be<decltype(count)>(data_size()))); }
 
 		force_inline T& operator *() const
 		{
 			return vm::get_ref<T>(vm::cast(m_addr));
 		}
 
-		force_inline T& operator [](typename remove_be_t<AT>::type index) const
-		{
-			return vm::get_ref<T>(vm::cast(m_addr + data_size() * index));
-		}
-
-		force_inline T& operator [](typename to_be_t<AT>::forced_type index) const
+		force_inline T& operator [](to_ne_t<AT> index) const
 		{
 			return vm::get_ref<T>(vm::cast(m_addr + data_size() * index));
 		}
@@ -191,25 +184,22 @@ namespace vm
 		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
 		explicit operator bool() const { return m_addr != 0; }
 		explicit operator T*() const { return get_ptr(); }
+
+		template<typename AT2> operator _ptr_base<T, 1, AT2>() const
+		{
+			return{ convert_le_be<AT2>(m_addr) };
+		}
 		
 		AT addr() const
 		{
 			return m_addr;
 		}
 
-		template<typename U>
-		void set(U&& value)
+		template<typename U> void set(U&& value)
 		{
 			m_addr = convert_le_be<AT>(value);
 		}
 
-		template<typename AT2>
-		operator _ptr_base<T, 1, AT2>() const
-		{
-			AT2 addr = convert_le_be<AT2>(m_addr);
-			return reinterpret_cast<_ptr_base<T, 1, AT2>&>(addr);
-		}
-
 		T* get_ptr() const
 		{
 			return vm::get_ptr<T>(vm::cast(m_addr));
@@ -220,9 +210,9 @@ namespace vm
 			return vm::priv_ptr<T>(vm::cast(m_addr));
 		}
 		
-		static const _ptr_base make(const AT& addr)
+		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
 		{
-			return reinterpret_cast<const _ptr_base&>(addr);
+			return{ convert_le_be<AT>(addr) };
 		}
 
 		_ptr_base& operator = (const _ptr_base& right) = default;
@@ -269,23 +259,19 @@ namespace vm
 		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
 		explicit operator bool() const { return m_addr != 0; }
 
-		template<typename AT2>
-		operator _ptr_base<void, 1, AT2>() const
+		template<typename AT2> operator _ptr_base<void, 1, AT2>() const
 		{
-			AT2 addr = convert_le_be<AT2>(m_addr);
-			return reinterpret_cast<_ptr_base<void, 1, AT2>&>(addr);
+			return{ convert_le_be<AT2>(m_addr) };
 		}
 
-		template<typename AT2>
-		operator _ptr_base<const void, 1, AT2>() const
+		template<typename AT2> operator _ptr_base<const void, 1, AT2>() const
 		{
-			AT2 addr = convert_le_be<AT2>(m_addr);
-			return reinterpret_cast<_ptr_base<const void, 1, AT2>&>(addr);
+			return{ convert_le_be<AT2>(m_addr) };
 		}
 
-		static const _ptr_base make(const AT& addr)
+		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
 		{
-			return reinterpret_cast<const _ptr_base&>(addr);
+			return{ convert_le_be<AT>(addr) };
 		}
 
 		_ptr_base& operator = (const _ptr_base& right) = default;
@@ -332,16 +318,14 @@ namespace vm
 		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
 		explicit operator bool() const { return m_addr != 0; }
 
-		template<typename AT2>
-		operator _ptr_base<const void, 1, AT2>() const
+		template<typename AT2> operator _ptr_base<const void, 1, AT2>() const
 		{
-			AT2 addr = convert_le_be<AT2>(m_addr);
-			return reinterpret_cast<_ptr_base<const void, 1, AT2>&>(addr);
+			return{ convert_le_be<AT2>(m_addr) };
 		}
 
-		static const _ptr_base make(const AT& addr)
+		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
 		{
-			return reinterpret_cast<const _ptr_base&>(addr);
+			return{ convert_le_be<AT>(addr) };
 		}
 
 		_ptr_base& operator = (const _ptr_base& right) = default;
@@ -384,16 +368,14 @@ namespace vm
 		force_inline bool operator !=(const nullptr_t& right) const { return m_addr != 0; }
 		explicit operator bool() const { return m_addr != 0; }
 
-		template<typename AT2>
-		operator _ptr_base<type, 1, AT2>() const
+		template<typename AT2> operator _ptr_base<type, 1, AT2>() const
 		{
-			AT2 addr = convert_le_be<AT2>(m_addr);
-			return reinterpret_cast<_ptr_base<type, 1, AT2>&>(addr);
+			return{ convert_le_be<AT2>(m_addr) };
 		}
 
-		static const _ptr_base make(const AT& addr)
+		template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
 		{
-			return reinterpret_cast<const _ptr_base&>(addr);
+			return{ convert_le_be<AT>(addr) };
 		}
 
 		operator const std::function<type>() const
@@ -414,22 +396,22 @@ namespace vm
 	};
 
 	// Native endianness pointer to LE data
-	template<typename T, int lvl = 1, typename AT = u32> using ptrl = _ptr_base<typename to_le_t<T>::type, lvl, AT>;
+	template<typename T, int lvl = 1, typename AT = u32> using ptrl = _ptr_base<to_le_t<T>, lvl, AT>;
 
 	// Native endianness pointer to BE data
-	template<typename T, int lvl = 1, typename AT = u32> using ptrb = _ptr_base<typename to_be_t<T>::type, lvl, AT>;
+	template<typename T, int lvl = 1, typename AT = u32> using ptrb = _ptr_base<to_be_t<T>, lvl, AT>;
 
 	// BE pointer to LE data
-	template<typename T, int lvl = 1, typename AT = u32> using bptrl = _ptr_base<typename to_le_t<T>::type, lvl, typename to_be_t<AT>::type>;
+	template<typename T, int lvl = 1, typename AT = u32> using bptrl = _ptr_base<to_le_t<T>, lvl, to_be_t<AT>>;
 
 	// BE pointer to BE data
-	template<typename T, int lvl = 1, typename AT = u32> using bptrb = _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>;
+	template<typename T, int lvl = 1, typename AT = u32> using bptrb = _ptr_base<to_be_t<T>, lvl, to_be_t<AT>>;
 
 	// LE pointer to LE data
-	template<typename T, int lvl = 1, typename AT = u32> using lptrl = _ptr_base<typename to_le_t<T>::type, lvl, typename to_le_t<AT>::type>;
+	template<typename T, int lvl = 1, typename AT = u32> using lptrl = _ptr_base<to_le_t<T>, lvl, to_le_t<AT>>;
 
 	// LE pointer to BE data
-	template<typename T, int lvl = 1, typename AT = u32> using lptrb = _ptr_base<typename to_be_t<T>::type, lvl, typename to_le_t<AT>::type>;
+	template<typename T, int lvl = 1, typename AT = u32> using lptrb = _ptr_base<to_be_t<T>, lvl, to_le_t<AT>>;
 
 	namespace ps3
 	{
@@ -456,8 +438,7 @@ namespace vm
 	{
 		template<typename T, int lvl, typename AT> operator _ptr_base<T, lvl, AT>() const
 		{
-			const std::array<AT, 1> value = {};
-			return _ptr_base<T, lvl, AT>::make(value[0]);
+			return{};
 		}
 	};
 
@@ -465,6 +446,37 @@ namespace vm
 	static null_t null;
 }
 
+// external specialization for is_be_t<>
+
+template<typename T, int lvl, typename AT>
+struct is_be_t<vm::_ptr_base<T, lvl, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
+{
+};
+
+// external specialization for to_ne_t<>
+
+template<typename T, int lvl, typename AT>
+struct to_ne<vm::_ptr_base<T, lvl, AT>>
+{
+	using type = vm::_ptr_base<T, lvl, to_ne_t<AT>>;
+};
+
+// external specialization for to_be_t<>
+
+template<typename T, int lvl, typename AT>
+struct to_be<vm::_ptr_base<T, lvl, AT>>
+{
+	using type = vm::_ptr_base<T, lvl, to_be_t<AT>>;
+};
+
+// external specialization for to_le_t<> (not used)
+
+template<typename T, int lvl, typename AT>
+struct to_le<vm::_ptr_base<T, lvl, AT>>
+{
+	using type = vm::_ptr_base<T, lvl, to_le_t<AT>>;
+};
+
 namespace fmt
 {
 	// external specialization for fmt::format function
@@ -472,7 +484,7 @@ namespace fmt
 	template<typename T, int lvl, typename AT>
 	struct unveil<vm::_ptr_base<T, lvl, AT>, false>
 	{
-		typedef typename unveil<AT>::result_type result_type;
+		using result_type = typename unveil<AT>::result_type;
 
 		force_inline static result_type get_value(const vm::_ptr_base<T, lvl, AT>& arg)
 		{
diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index a2e7903d16..ccc5528370 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -3,26 +3,30 @@
 namespace vm
 {
 	template<typename T, typename AT = u32>
-	class _ref_base
+	struct _ref_base
 	{
-	protected:
-		AT m_addr;
+		const AT m_addr;
+
+		using type = T;
 
-	public:
-		typedef T type;
 		static_assert(!std::is_pointer<T>::value, "vm::_ref_base<> error: invalid type (pointer)");
 		static_assert(!std::is_reference<T>::value, "vm::_ref_base<> error: invalid type (reference)");
-		typedef typename remove_be_t<T>::type le_type;
-		typedef typename to_be_t<T>::type be_type;
 
-		operator T&()
+		//template<typename CT> operator std::enable_if_t<std::is_convertible<T, CT>::value, CT>()
+		//{
+		//	return get_ref<T>(m_addr);
+		//}
+		
+		// temporarily, because SFINAE doesn't work for some reason:
+
+		operator to_ne_t<T>() const
 		{
 			return get_ref<T>(m_addr);
 		}
 
-		operator const T&() const
+		operator T() const
 		{
-			return get_ref<const T>(m_addr);
+			return get_ref<T>(m_addr);
 		}
 
 		AT addr() const
@@ -32,28 +36,16 @@ namespace vm
 
 		static _ref_base make(const AT& addr)
 		{
-			return reinterpret_cast<_ref_base&>(addr);
+			return{ addr };
 		}
 
-		_ref_base& operator = (le_type right)
+		template<typename CT> const _ref_base& operator =(const _ref_base<T, CT>& right) const
 		{
 			get_ref<T>(m_addr) = right;
 			return *this;
 		}
 
-		const _ref_base& operator = (le_type right) const
-		{
-			get_ref<T>(m_addr) = right;
-			return *this;
-		}
-
-		_ref_base& operator = (be_type right)
-		{
-			get_ref<T>(m_addr) = right;
-			return *this;
-		}
-
-		const _ref_base& operator = (be_type right) const
+		template<typename CT> std::enable_if_t<std::is_assignable<T&, CT>::value, const _ref_base&> operator =(const CT& right) const
 		{
 			get_ref<T>(m_addr) = right;
 			return *this;
@@ -61,22 +53,22 @@ namespace vm
 	};
 
 	// Native endianness reference to LE data
-	template<typename T, typename AT = u32> using refl = _ref_base<typename to_le_t<T>::type, AT>;
+	template<typename T, typename AT = u32> using refl = _ref_base<to_le_t<T>, AT>;
 
 	// Native endianness reference to BE data
-	template<typename T, typename AT = u32> using refb = _ref_base<typename to_be_t<T>::type, AT>;
+	template<typename T, typename AT = u32> using refb = _ref_base<to_be_t<T>, AT>;
 
 	// BE reference to LE data
-	template<typename T, typename AT = u32> using brefl = _ref_base<typename to_le_t<T>::type, typename to_be_t<AT>::type>;
+	template<typename T, typename AT = u32> using brefl = _ref_base<to_le_t<T>, to_be_t<AT>>;
 
 	// BE reference to BE data
-	template<typename T, typename AT = u32> using brefb = _ref_base<typename to_be_t<T>::type, typename to_be_t<AT>::type>;
+	template<typename T, typename AT = u32> using brefb = _ref_base<to_be_t<T>, to_be_t<AT>>;
 
 	// LE reference to LE data
-	template<typename T, typename AT = u32> using lrefl = _ref_base<typename to_le_t<T>::type, typename to_le_t<AT>::type>;
+	template<typename T, typename AT = u32> using lrefl = _ref_base<to_le_t<T>, to_le_t<AT>>;
 
 	// LE reference to BE data
-	template<typename T, typename AT = u32> using lrefb = _ref_base<typename to_be_t<T>::type, typename to_le_t<AT>::type>;
+	template<typename T, typename AT = u32> using lrefb = _ref_base<to_be_t<T>, to_le_t<AT>>;
 
 	namespace ps3
 	{
@@ -98,7 +90,38 @@ namespace vm
 
 	//PS3 emulation is main now, so lets it be as default
 	using namespace ps3;
-}
+};
+
+// external specialization for is_be_t<>
+
+template<typename T, typename AT>
+struct is_be_t<vm::_ref_base<T, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
+{
+};
+
+// external specialization for to_ne_t<>
+
+template<typename T, typename AT>
+struct to_ne<vm::_ref_base<T, AT>>
+{
+	using type = vm::_ref_base<T, to_ne_t<AT>>;
+};
+
+// external specialization for to_be_t<>
+
+template<typename T, typename AT>
+struct to_be<vm::_ref_base<T, AT>>
+{
+	using type = vm::_ref_base<T, to_be_t<AT>>;
+};
+
+// external specialization for to_le_t<> (not used)
+
+template<typename T, typename AT>
+struct to_le<vm::_ref_base<T, AT>>
+{
+	using type = vm::_ref_base<T, to_le_t<AT>>;
+};
 
 namespace fmt
 {
@@ -107,7 +130,7 @@ namespace fmt
 	template<typename T, typename AT>
 	struct unveil<vm::_ref_base<T, AT>, false>
 	{
-		typedef typename unveil<AT>::result_type result_type;
+		using result_type = typename unveil<AT>::result_type;
 
 		force_inline static result_type get_value(const vm::_ref_base<T, AT>& arg)
 		{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.h b/rpcs3/Emu/SysCalls/Modules/cellGifDec.h
index b958150908..9b599425ff 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.h
@@ -1,6 +1,6 @@
 #pragma once
 
-//Return Codes
+// Return Codes
 enum
 {
 	CELL_GIFDEC_ERROR_OPEN_FILE     = 0x80611300,
@@ -19,10 +19,10 @@ enum CellGifDecStreamSrcSel
 	CELL_GIFDEC_BUFFER = 1, // Input from a buffer
 };
 
-enum CellGifDecColorSpace
+enum CellGifDecSpuThreadEna
 {
-	CELL_GIFDEC_RGBA = 10,
-	CELL_GIFDEC_ARGB = 20,
+	CELL_GIFDEC_SPU_THREAD_DISABLE = 0, // Do not use SPU threads
+	CELL_GIFDEC_SPU_THREAD_ENABLE  = 1, // Use SPU threads
 };
 
 enum CellGifDecRecordType
@@ -32,10 +32,22 @@ enum CellGifDecRecordType
 	CELL_GIFDEC_RECORD_TYPE_TERMINATE  = 3, // Trailer block
 };
 
+enum CellGifDecColorSpace
+{
+	CELL_GIFDEC_RGBA = 10, // RGBA
+	CELL_GIFDEC_ARGB = 20, // ARGB
+};
+
+enum CellGifDecCommand
+{
+	CELL_GIFDEC_CONTINUE = 0, // Continue decoding
+	CELL_GIFDEC_STOP     = 1, // Force decoding to stop
+};
+
 enum CellGifDecDecodeStatus
 {
-	CELL_GIFDEC_DEC_STATUS_FINISH = 0, //Decoding finished
-	CELL_GIFDEC_DEC_STATUS_STOP   = 1, //Decoding halted
+	CELL_GIFDEC_DEC_STATUS_FINISH = 0, // Decoding finished
+	CELL_GIFDEC_DEC_STATUS_STOP   = 1, // Decoding was stopped
 };
 
 struct CellGifDecInfo
@@ -65,9 +77,9 @@ struct CellGifDecInParam
 {
 	be_t<u32> commandPtr;
 	be_t<u32> colorSpace; // CellGifDecColorSpace
-	be_t<u8> outputColorAlpha1;
-	be_t<u8> outputColorAlpha2;
-	be_t<u8> reserved[2];
+	u8 outputColorAlpha1;
+	u8 outputColorAlpha2;
+	u8 reserved[2];
 };
 
 struct CellGifDecOutParam
@@ -83,8 +95,8 @@ struct CellGifDecOutParam
 
 struct CellGifDecExtension
 {
-	be_t<u8> label;
-	be_t<u32> data;
+	u8 label;
+	vm::ptr<u8> data;
 };
 
 struct CellGifDecDataOutInfo
diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.h b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.h
index d4d138839e..2450eb9977 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.h
@@ -71,8 +71,8 @@ struct CellJpgDecInParam
 	be_t<u32> method;           // CellJpgDecMethod
 	be_t<u32> outputMode;       // CellJpgDecOutputMode
 	be_t<u32> outputColorSpace; // CellJpgDecColorSpace
-	be_t<u8> outputColorAlpha;
-	be_t<u8> reserved[3];
+	u8 outputColorAlpha;
+	u8 reserved[3];
 };
 
 struct CellJpgDecOutParam
diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
index a29aec4262..4bdaa41196 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
@@ -2,44 +2,47 @@
 #include "Emu/Memory/Memory.h"
 #include "Emu/SysCalls/Modules.h"
 
-#include "cellL10n.h"
-#include <stdio.h>
-#include <stdlib.h>
-
 #ifdef _MSC_VER
 #include <windows.h>
-#include <wchar.h>
-#include <codecvt>
 #else
 #include <iconv.h>
 #endif
 
+#include "cellL10n.h"
+#include <codecvt>
+#include <stdio.h>
+#include <stdlib.h>
+
 extern Module cellL10n;
 
-int UTF16stoUTF8s(vm::lptrl<const char16_t> utf16, vm::ptr<u32> utf16_len, vm::ptr<char> utf8, vm::ptr<u32> utf8_len)
+s32 UTF16stoUTF8s(vm::ptr<const char16_t> utf16, vm::ref<u32> utf16_len, vm::ptr<char> utf8, vm::ref<u32> utf8_len)
 {
-	cellL10n.Warning("UTF16stoUTF8s(utf16_addr=0x%x, utf16_len_addr=0x%x, utf8_addr=0x%x, utf8_len_addr=0x%x)",
-		utf16.addr(), utf16_len.addr(), utf8.addr(), utf8_len.addr());
+	cellL10n.Warning("UTF16stoUTF8s(utf16=*0x%x, utf16_len=*0x%x, utf8=*0x%x, utf8_len=*0x%x)", utf16, utf16_len, utf8, utf8_len);
 
-	std::u16string wstr = utf16.get_ptr(); // ???
-	wstr.resize(*utf16_len); // TODO: Is this really the role of utf16_len in this function?
-#ifdef _MSC_VER
-	std::wstring_convert<std::codecvt_utf8_utf16<char16_t>,char16_t> convert;
+	std::u16string wstr;
+	wstr.resize(utf16_len);
+
+	for (auto& wc : wstr)
+	{
+		wc = *utf16++;
+	}
+
+	std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
 	std::string str = convert.to_bytes(wstr);
 
-	if (*utf8_len < str.size())
+	if (utf8_len < str.size())
 	{
-		*utf8_len = str.size();
+		utf8_len = str.size();
 		return DSTExhausted;
 	}
 
-	*utf8_len = str.size();
+	utf8_len = str.size();
 	memcpy(utf8.get_ptr(), str.c_str(), str.size());
-#endif
+
 	return ConversionOK;
 }
 
-int jstrchk(vm::ptr<const char> jstr)
+s32 jstrchk(vm::ptr<const char> jstr)
 {
 	cellL10n.Warning("jstrchk(jstr_addr=0x%x) -> utf8", jstr.addr());
 
@@ -48,7 +51,7 @@ int jstrchk(vm::ptr<const char> jstr)
 
 //translate code id to code name. some codepage may has another name.
 //If this makes your compilation fail, try replace the string code with one in "iconv -l"
-bool _L10nCodeParse(int code, std::string& retCode)
+bool _L10nCodeParse(s32 code, std::string& retCode)
 {
 	if ((code >= _L10N_CODE_) || (code < 0)) return false;
 	switch (code)
@@ -113,7 +116,7 @@ bool _L10nCodeParse(int code, std::string& retCode)
 
 //translate code id to code name.
 //If this makes your compilation fail, try replace the string code with one in "iconv -l"
-bool _L10nCodeParse(int code, unsigned int & retCode)
+bool _L10nCodeParse(s32 code, u32& retCode)
 {
 	retCode = 0;
 	if ((code >= _L10N_CODE_) || (code < 0)) return false;
@@ -182,10 +185,10 @@ bool _L10nCodeParse(int code, unsigned int & retCode)
 #ifdef _MSC_VER
 
 //Use code page to transform std::string to std::wstring.
-int _OEM2Wide(unsigned int oem_code, const std::string src, std::wstring& dst)
+s32 _OEM2Wide(u32 oem_code, const std::string src, std::wstring& dst)
 {
 	//Such length returned should include the '\0' character.
-	int length = MultiByteToWideChar(oem_code, 0, src.c_str(), -1, NULL, 0);
+	s32 length = MultiByteToWideChar(oem_code, 0, src.c_str(), -1, NULL, 0);
 	wchar_t *store = new wchar_t[length]();
 
 	MultiByteToWideChar(oem_code, 0, src.c_str(), -1, (LPWSTR)store, length);
@@ -199,10 +202,10 @@ int _OEM2Wide(unsigned int oem_code, const std::string src, std::wstring& dst)
 }
 
 //Use Code page to transform std::wstring to std::string.
-int _Wide2OEM(unsigned int oem_code, const std::wstring src, std::string& dst)
+s32 _Wide2OEM(u32 oem_code, const std::wstring src, std::string& dst)
 {
 	//Such length returned should include the '\0' character.
-	int length = WideCharToMultiByte(oem_code, 0, src.c_str(), -1, NULL, 0, NULL, NULL);
+	s32 length = WideCharToMultiByte(oem_code, 0, src.c_str(), -1, NULL, 0, NULL, NULL);
 	char *store = new char[length]();
 
 	WideCharToMultiByte(oem_code, 0, src.c_str(), -1, store, length, NULL, NULL);
@@ -216,7 +219,7 @@ int _Wide2OEM(unsigned int oem_code, const std::wstring src, std::string& dst)
 }
 
 //Convert Codepage to Codepage (all char*)
-std::string _OemToOem(unsigned int src_code, unsigned int dst_code, const std::string str)
+std::string _OemToOem(u32 src_code, u32 dst_code, const std::string str)
 {
 	std::wstring wide; std::string result;
 	_OEM2Wide(src_code, str, wide);
@@ -227,9 +230,9 @@ std::string _OemToOem(unsigned int src_code, unsigned int dst_code, const std::s
 /*
 //Original piece of code. and this is for windows using with _OEM2Wide,_Wide2OEM,_OemToOem.
 //The Char -> Char Execution of this function has already been tested using VS and CJK text with encoding.
-int _L10nConvertStr(int src_code, const void *src, size_t * src_len, int dst_code, void *dst, size_t * dst_len)
+s32 _L10nConvertStr(s32 src_code, const void *src, size_t * src_len, s32 dst_code, void *dst, size_t * dst_len)
 {
-	unsigned int srcCode = 0, dstCode = 0;	//OEM code pages
+	u32 srcCode = 0, dstCode = 0;	//OEM code pages
 	bool src_page_converted = _L10nCodeParse(src_code, srcCode);	//Check if code is in list.
 	bool dst_page_converted = _L10nCodeParse(dst_code, dstCode);
 
@@ -251,10 +254,10 @@ int _L10nConvertStr(int src_code, const void *src, size_t * src_len, int dst_cod
 }
 //This is the one used with iconv library for linux/mac. Also char->char.
 //I've tested the code with console apps using codeblocks.
-int _L10nConvertStr(int src_code, const void* src, size_t * src_len, int dst_code, void * dst, size_t * dst_len)
+s32 _L10nConvertStr(s32 src_code, const void* src, size_t * src_len, s32 dst_code, void * dst, size_t * dst_len)
 {
 	std::string srcCode, dstCode;
-	int retValue = ConversionOK;
+	s32 retValue = ConversionOK;
 	if ((_L10nCodeParse(src_code, srcCode)) && (_L10nCodeParse(dst_code, dstCode)))
 	{
 		iconv_t ict = iconv_open(srcCode.c_str(), dstCode.c_str());
@@ -281,13 +284,13 @@ int _L10nConvertStr(int src_code, const void* src, size_t * src_len, int dst_cod
 #endif
 
 //TODO: Check the code in emulation. If support for UTF8/UTF16/UTF32/UCS2/UCS4 should use wider chars.. awful.
-int L10nConvertStr(int src_code, vm::ptr<const void> src, vm::ptr<u32> src_len, int dst_code, vm::ptr<void> dst, vm::ptr<u32> dst_len)
+s32 L10nConvertStr(s32 src_code, vm::ptr<const void> src, vm::ptr<u32> src_len, s32 dst_code, vm::ptr<void> dst, vm::ptr<u32> dst_len)
 {
 	cellL10n.Error("L10nConvertStr(src_code=%d, srca_addr=0x%x, src_len_addr=0x%x, dst_code=%d, dst_addr=0x%x, dst_len_addr=0x%x)",
 		src_code, src.addr(), src_len.addr(), dst_code, dst.addr(), dst_len.addr());
 	//cellL10n.Todo("L10nConvertStr: 1st char at dst: 0x%x", *((char*)src.get_ptr()));
 #ifdef _MSC_VER
-	unsigned int srcCode = 0, dstCode = 0;	//OEM code pages
+	u32 srcCode = 0, dstCode = 0;	//OEM code pages
 	bool src_page_converted = _L10nCodeParse(src_code, srcCode);	//Check if code is in list.
 	bool dst_page_converted = _L10nCodeParse(dst_code, dstCode);
 
@@ -308,7 +311,7 @@ int L10nConvertStr(int src_code, vm::ptr<const void> src, vm::ptr<u32> src_len,
 	return ConversionOK;
 #else
 	std::string srcCode, dstCode;
-	int retValue = ConversionOK;
+	s32 retValue = ConversionOK;
 	if ((_L10nCodeParse(src_code, srcCode)) && (_L10nCodeParse(dst_code, dstCode)))
 	{
 		iconv_t ict = iconv_open(srcCode.c_str(), dstCode.c_str());
@@ -490,7 +493,7 @@ Module cellL10n("cellL10n", []()
 	// REG_FUNC(cellL10n, UTF8stoHZs);
 	// REG_FUNC(cellL10n, eucjp2kuten);
 	// REG_FUNC(cellL10n, UTF8toBIG5);
-	// REG_FUNC(cellL10n, UTF16stoUTF8s);
+	REG_FUNC(cellL10n, UTF16stoUTF8s);
 	// REG_FUNC(cellL10n, JISstoUCS2s);
 	// REG_FUNC(cellL10n, GB18030toUTF8);
 	// REG_FUNC(cellL10n, UTF8toSJIS);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.h b/rpcs3/Emu/SysCalls/Modules/cellL10n.h
index 512d2a4bcf..74a8b6cec9 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.h
@@ -1,9 +1,4 @@
-#include "stdafx.h"
-
-// Requires GCC 4.10 apparently..
-#ifdef _MSC_VER
-#include <codecvt>
-#endif
+#pragma once
 
 // L10nResult
 enum
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index 58eab5a692..fc59a1410a 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -18,7 +18,7 @@ extern "C"
 extern Module cellPngDec;
 
 s32 pngDecCreate(
-	vm::ptr<u32> mainHandle,
+	vm::ptr<CellPngDecMainHandle> mainHandle,
 	vm::ptr<const CellPngDecThreadInParam> param,
 	vm::ptr<const CellPngDecExtThreadInParam> ext = vm::null)
 {
@@ -41,7 +41,7 @@ s32 pngDecCreate(
 	}
 	
 	// use virtual memory address as a handle
-	*mainHandle = dec.addr();
+	*mainHandle = dec;
 
 	return CELL_OK;
 }
@@ -58,7 +58,7 @@ s32 pngDecDestroy(CellPngDecMainHandle dec)
 
 s32 pngDecOpen(
 	CellPngDecMainHandle dec,
-	vm::ptr<u32> subHandle,
+	vm::ptr<CellPngDecSubHandle> subHandle,
 	vm::ptr<const CellPngDecSrc> src,
 	vm::ptr<CellPngDecOpnInfo> openInfo,
 	vm::ptr<const CellPngDecCbCtrlStrm> cb = vm::null,
@@ -105,7 +105,7 @@ s32 pngDecOpen(
 	}
 
 	// use virtual memory address as a handle
-	*subHandle = stream.addr();
+	*subHandle = stream;
 
 	// set memory info
 	openInfo->initSpaceAllocated = 4096;
@@ -366,7 +366,10 @@ s32 pngDecodeData(
 	return CELL_OK;
 }
 
-s32 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam)
+s32 cellPngDecCreate(
+	vm::ptr<CellPngDecMainHandle> mainHandle,
+	vm::ptr<const CellPngDecThreadInParam> threadInParam,
+	vm::ptr<CellPngDecThreadOutParam> threadOutParam)
 {
 	cellPngDec.Warning("cellPngDecCreate(mainHandle=**0x%x, threadInParam=*0x%x, threadOutParam=*0x%x)", mainHandle, threadInParam, threadOutParam);
 
@@ -380,7 +383,7 @@ s32 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInPa
 }
 
 s32 cellPngDecExtCreate(
-	vm::ptr<u32> mainHandle,
+	vm::ptr<CellPngDecMainHandle> mainHandle,
 	vm::ptr<const CellPngDecThreadInParam> threadInParam,
 	vm::ptr<CellPngDecThreadOutParam> threadOutParam,
 	vm::ptr<const CellPngDecExtThreadInParam> extThreadInParam,
@@ -410,7 +413,7 @@ s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle)
 
 s32 cellPngDecOpen(
 	CellPngDecMainHandle mainHandle,
-	vm::ptr<u32> subHandle,
+	vm::ptr<CellPngDecSubHandle> subHandle,
 	vm::ptr<const CellPngDecSrc> src,
 	vm::ptr<CellPngDecOpnInfo> openInfo)
 {
@@ -422,7 +425,7 @@ s32 cellPngDecOpen(
 
 s32 cellPngDecExtOpen(
 	CellPngDecMainHandle mainHandle,
-	vm::ptr<u32> subHandle,
+	vm::ptr<CellPngDecSubHandle> subHandle,
 	vm::ptr<const CellPngDecSrc> src,
 	vm::ptr<CellPngDecOpnInfo> openInfo,
 	vm::ptr<const CellPngDecCbCtrlStrm> cbCtrlStrm,
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.h b/rpcs3/Emu/SysCalls/Modules/cellPngDec.h
index 361d83fe07..4837b2024e 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.h
@@ -6,11 +6,8 @@ enum : u32
 	PNGDEC_CODEC_VERSION = 0x00420000,
 };
 
-struct PngDecoder;
-struct PngStream;
-
-typedef vm::ptr<PngDecoder> CellPngDecMainHandle;
-typedef vm::ptr<PngStream> CellPngDecSubHandle;
+using CellPngDecMainHandle = vm::ptr<struct PngDecoder>;
+using CellPngDecSubHandle = vm::ptr<struct PngStream>;
 
 // Return Codes
 enum
@@ -28,7 +25,7 @@ enum
 };
 
 // Consts
-enum CellPngDecColorSpace : u32
+enum CellPngDecColorSpace : s32
 {
 	CELL_PNGDEC_GRAYSCALE       = 1,
 	CELL_PNGDEC_RGB             = 2,
@@ -38,62 +35,62 @@ enum CellPngDecColorSpace : u32
 	CELL_PNGDEC_ARGB            = 20,
 };
 
-enum CellPngDecSpuThreadEna : u32
+enum CellPngDecSpuThreadEna : s32
 {
 	CELL_PNGDEC_SPU_THREAD_DISABLE = 0,
 	CELL_PNGDEC_SPU_THREAD_ENABLE  = 1,
 };
 
-enum CellPngDecStreamSrcSel : u32
+enum CellPngDecStreamSrcSel : s32
 {
 	CELL_PNGDEC_FILE   = 0,
 	CELL_PNGDEC_BUFFER = 1,
 };
 
-enum CellPngDecInterlaceMode : u32
+enum CellPngDecInterlaceMode : s32
 {
 	CELL_PNGDEC_NO_INTERLACE = 0,
 	CELL_PNGDEC_ADAM7_INTERLACE = 1,
 };
 
-enum CellPngDecOutputMode : u32
+enum CellPngDecOutputMode : s32
 {
 	CELL_PNGDEC_TOP_TO_BOTTOM = 0,
 	CELL_PNGDEC_BOTTOM_TO_TOP = 1,
 };
 
-enum CellPngDecPackFlag : u32
+enum CellPngDecPackFlag : s32
 {
 	CELL_PNGDEC_1BYTE_PER_NPIXEL = 0,
 	CELL_PNGDEC_1BYTE_PER_1PIXEL = 1,
 };
 
-enum CellPngDecAlphaSelect : u32
+enum CellPngDecAlphaSelect : s32
 {
 	CELL_PNGDEC_STREAM_ALPHA = 0,
 	CELL_PNGDEC_FIX_ALPHA    = 1,
 };
 
-enum CellPngDecCommand : u32
+enum CellPngDecCommand : s32
 {
 	CELL_PNGDEC_CONTINUE = 0,
 	CELL_PNGDEC_STOP     = 1,
 };
 
-enum CellPngDecDecodeStatus : u32
+enum CellPngDecDecodeStatus : s32
 {
 	CELL_PNGDEC_DEC_STATUS_FINISH = 0,
 	CELL_PNGDEC_DEC_STATUS_STOP   = 1,
 };
 
-// Callbacks
+// Callbacks for memory management
 typedef vm::ptr<void>(CellPngDecCbControlMalloc)(u32 size, vm::ptr<void> cbCtrlMallocArg);
 typedef s32(CellPngDecCbControlFree)(vm::ptr<void> ptr, vm::ptr<void> cbCtrlFreeArg);
 
 // Structs
 struct CellPngDecThreadInParam
 {
-	be_t<CellPngDecSpuThreadEna> spuThreadEnable;
+	be_t<s32> spuThreadEnable; // CellPngDecSpuThreadEna
 	be_t<u32> ppuThreadPriority;
 	be_t<u32> spuThreadPriority;
 	vm::bptr<CellPngDecCbControlMalloc> cbCtrlMallocFunc;
@@ -104,7 +101,7 @@ struct CellPngDecThreadInParam
 
 struct CellPngDecExtThreadInParam
 {
-	be_t<u32> spurs_addr; // it could be vm::bptr<CellSpurs>, but nobody will use SPURS in HLE implementation
+	vm::bptr<struct CellSpurs> spurs;
 	u8 priority[8];
 	be_t<u32> maxContention;
 };
@@ -121,13 +118,13 @@ struct CellPngDecExtThreadOutParam
 
 struct CellPngDecSrc
 {
-	be_t<CellPngDecStreamSrcSel> srcSelect;
+	be_t<s32> srcSelect; // CellPngDecStreamSrcSel
 	vm::bptr<const char> fileName;
 	be_t<s64> fileOffset;
 	be_t<u32> fileSize;
 	vm::bptr<void> streamPtr;
 	be_t<u32> streamSize;
-	be_t<CellPngDecSpuThreadEna> spuThreadEnable;
+	be_t<s32> spuThreadEnable; // CellGifDecSpuThreadEna
 };
 
 struct CellPngDecOpnInfo
@@ -140,20 +137,20 @@ struct CellPngDecInfo
 	be_t<u32> imageWidth;
 	be_t<u32> imageHeight;
 	be_t<u32> numComponents;
-	be_t<CellPngDecColorSpace> colorSpace;
+	be_t<s32> colorSpace; // CellPngDecColorSpace
 	be_t<u32> bitDepth;
-	be_t<CellPngDecInterlaceMode> interlaceMethod;
+	be_t<s32> interlaceMethod; // CellPngDecInterlaceMode
 	be_t<u32> chunkInformation;
 };
 
 struct CellPngDecInParam
 {
-	vm::bptr<volatile CellPngDecCommand> commandPtr;
-	be_t<CellPngDecOutputMode> outputMode;
-	be_t<CellPngDecColorSpace> outputColorSpace;
+	vm::bptr<volatile s32> commandPtr; // CellPngDecCommand
+	be_t<s32> outputMode; // CellPngDecOutputMode
+	be_t<s32> outputColorSpace; // CellPngDecColorSpace
 	be_t<u32> outputBitDepth;
-	be_t<CellPngDecPackFlag> outputPackFlag;
-	be_t<CellPngDecAlphaSelect> outputAlphaSelect;
+	be_t<s32> outputPackFlag; // CellPngDecPackFlag
+	be_t<s32> outputAlphaSelect; // CellPngDecAlphaSelect
 	be_t<u32> outputColorAlpha;
 };
 
@@ -164,8 +161,8 @@ struct CellPngDecOutParam
 	be_t<u32> outputHeight;
 	be_t<u32> outputComponents;
 	be_t<u32> outputBitDepth;
-	be_t<CellPngDecOutputMode> outputMode;
-	be_t<CellPngDecColorSpace> outputColorSpace;
+	be_t<s32> outputMode; // CellPngDecOutputMode
+	be_t<s32> outputColorSpace; // CellPngDecOutputMode
 	be_t<u32> useMemorySpace;
 };
 
@@ -179,14 +176,17 @@ struct CellPngDecDataOutInfo
 	be_t<u32> chunkInformation;
 	be_t<u32> numText;
 	be_t<u32> numUnknownChunk;
-	be_t<CellPngDecDecodeStatus> status;
+	be_t<s32> status; // CellPngDecDecodeStatus
 };
 
 // Functions
-s32 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam);
+s32 cellPngDecCreate(
+	vm::ptr<CellPngDecMainHandle> mainHandle,
+	vm::ptr<const CellPngDecThreadInParam> threadInParam,
+	vm::ptr<CellPngDecThreadOutParam> threadOutParam);
 
 s32 cellPngDecExtCreate(
-	vm::ptr<u32> mainHandle,
+	vm::ptr<CellPngDecMainHandle> mainHandle,
 	vm::ptr<const CellPngDecThreadInParam> threadInParam,
 	vm::ptr<CellPngDecThreadOutParam> threadOutParam,
 	vm::ptr<const CellPngDecExtThreadInParam> extThreadInParam,
@@ -194,11 +194,14 @@ s32 cellPngDecExtCreate(
 
 s32 cellPngDecOpen(
 	CellPngDecMainHandle mainHandle,
-	vm::ptr<u32> subHandle,
+	vm::ptr<CellPngDecSubHandle> subHandle,
 	vm::ptr<const CellPngDecSrc> src,
 	vm::ptr<CellPngDecOpnInfo> openInfo);
 
-s32 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngDecInfo> info);
+s32 cellPngDecReadHeader(
+	CellPngDecMainHandle mainHandle,
+	CellPngDecSubHandle subHandle,
+	vm::ptr<CellPngDecInfo> info);
 
 s32 cellPngDecSetParameter(
 	CellPngDecMainHandle mainHandle,
@@ -217,11 +220,123 @@ s32 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHand
 
 s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle);
 
-s32 cellPngDecGetTextChunk(
+// Defines for decoding partial streams
+enum CellPngDecBufferMode : s32
+{
+	CELL_PNGDEC_LINE_MODE = 1,
+};
+
+enum CellPngDecSpuMode : s32
+{
+	CELL_PNGDEC_RECEIVE_EVENT    = 0,
+	CELL_PNGDEC_TRYRECEIVE_EVENT = 1,
+};
+
+// Structs for decoding partial streams
+struct CellPngDecStrmInfo
+{
+	be_t<u32> decodedStrmSize;
+};
+
+struct CellPngDecStrmParam
+{
+	vm::bptr<void> strmPtr;
+	be_t<u32> strmSize;
+};
+
+struct CellPngDecDispInfo
+{
+	be_t<u64> outputFrameWidthByte;
+	be_t<u32> outputFrameHeight;
+	be_t<u64> outputStartXByte;
+	be_t<u32> outputStartY;
+	be_t<u64> outputWidthByte;
+	be_t<u32> outputHeight;
+	be_t<u32> outputBitDepth;
+	be_t<u32> outputComponents;
+	be_t<u32> nextOutputStartY;
+	be_t<u32> scanPassCount;
+	vm::bptr<void> outputImage;
+};
+
+struct CellPngDecDispParam
+{
+	vm::bptr<void> nextOutputImage;
+};
+
+struct CellPngDecOpnParam
+{
+	be_t<u32> selectChunk;
+};
+
+struct CellPngDecExtInfo
+{
+	be_t<u64> reserved;
+};
+
+struct CellPngDecExtInParam
+{
+	be_t<s32> bufferMode; // CellPngDecBufferMode
+	be_t<u32> outputCounts;
+	be_t<s32> spuMode; // CellPngDecSpuMode
+};
+
+struct CellPngDecExtOutParam
+{
+	be_t<u64> outputWidthByte;
+	be_t<u32> outputHeight;
+};
+
+// Callbacks for decoding partial streams
+typedef s32(CellPngDecCbControlStream)(vm::ptr<CellPngDecStrmInfo> strmInfo, vm::ptr<CellPngDecStrmParam> strmParam, vm::ptr<void> cbCtrlStrmArg);
+typedef s32(CellPngDecCbControlDisp)(vm::ptr<CellPngDecDispInfo> dispInfo, vm::ptr<CellPngDecDispParam> dispParam, vm::ptr<void> cbCtrlDispArg);
+
+struct CellPngDecCbCtrlStrm
+{
+	vm::bptr<CellPngDecCbControlStream> cbCtrlStrmFunc;
+	vm::bptr<void> cbCtrlStrmArg;
+};
+
+struct CellPngDecCbCtrlDisp
+{
+	vm::bptr<CellPngDecCbControlDisp> cbCtrlDispFunc;
+	vm::bptr<void> cbCtrlDispArg;
+};
+
+// Functions for decoding partial streams
+s32 cellPngDecExtOpen(
+	CellPngDecMainHandle mainHandle,
+	vm::ptr<CellPngDecSubHandle> subHandle,
+	vm::ptr<const CellPngDecSrc> src,
+	vm::ptr<CellPngDecOpnInfo> openInfo,
+	vm::ptr<const CellPngDecCbCtrlStrm> cbCtrlStrm,
+	vm::ptr<const CellPngDecOpnParam> opnParam);
+
+s32 cellPngDecExtReadHeader(
 	CellPngDecMainHandle mainHandle,
 	CellPngDecSubHandle subHandle,
-	vm::ptr<u32> textInfoNum,
-	vm::ptr<vm::bptr<CellPngTextInfo>> textInfo);
+	vm::ptr<CellPngDecInfo> info,
+	vm::ptr<CellPngDecExtInfo> extInfo);
+
+s32 cellPngDecExtSetParameter(
+	CellPngDecMainHandle mainHandle,
+	CellPngDecSubHandle subHandle,
+	vm::ptr<const CellPngDecInParam> inParam,
+	vm::ptr<CellPngDecOutParam> outParam,
+	vm::ptr<const CellPngDecExtInParam> extInParam,
+	vm::ptr<CellPngDecExtOutParam> extOutParam);
+
+s32 cellPngDecExtDecodeData(
+	CellPngDecMainHandle mainHandle,
+	CellPngDecSubHandle subHandle,
+	vm::ptr<u8> data,
+	vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
+	vm::ptr<CellPngDecDataOutInfo> dataOutInfo,
+	vm::ptr<const CellPngDecCbCtrlDisp> cbCtrlDisp,
+	vm::ptr<CellPngDecDispParam> dispParam);
+
+// Functions for accessing ancillary chunks
+s32 cellPngDecGetTextChunk(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<u32> textInfoNum, vm::ptr<vm::bptr<CellPngTextInfo>> textInfo);
 
 s32 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPLTE> plte);
 
@@ -253,128 +368,7 @@ s32 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
 
 s32 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPCAL> pcal);
 
-s32 cellPngDecGetUnknownChunks(
-	CellPngDecMainHandle mainHandle,
-	CellPngDecSubHandle subHandle,
-	vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk,
-	vm::ptr<u32> unknownChunkNumber);
-
-
-enum CellPngDecBufferMode
-{
-	CELL_PNGDEC_LINE_MODE = 1,
-};
-
-enum CellPngDecSpuMode
-{
-	CELL_PNGDEC_RECEIVE_EVENT    = 0,
-	CELL_PNGDEC_TRYRECEIVE_EVENT = 1,
-};
-
-// Structs
-struct CellPngDecStrmInfo
-{
-	be_t<u32> decodedStrmSize;
-};
-
-struct CellPngDecStrmParam
-{
-	vm::bptr<void> strmPtr;
-	be_t<u32> strmSize;
-};
-
-typedef s32(CellPngDecCbControlStream)(vm::ptr<CellPngDecStrmInfo> strmInfo, vm::ptr<CellPngDecStrmParam> strmParam, vm::ptr<void> cbCtrlStrmArg);
-
-struct CellPngDecDispInfo
-{
-	be_t<u64> outputFrameWidthByte;
-	be_t<u32> outputFrameHeight;
-	be_t<u64> outputStartXByte;
-	be_t<u32> outputStartY;
-	be_t<u64> outputWidthByte;
-	be_t<u32> outputHeight;
-	be_t<u32> outputBitDepth;
-	be_t<u32> outputComponents;
-	be_t<u32> nextOutputStartY;
-	be_t<u32> scanPassCount;
-	vm::bptr<void> outputImage;
-};
-
-struct CellPngDecDispParam
-{
-	vm::bptr<void> nextOutputImage;
-};
-
-// Callback
-typedef s32(CellPngDecCbControlDisp)(vm::ptr<CellPngDecDispInfo> dispInfo, vm::ptr<CellPngDecDispParam> dispParam, vm::ptr<void> cbCtrlDispArg);
-
-// Structs
-struct CellPngDecOpnParam
-{
-	be_t<u32> selectChunk;
-};
-
-struct CellPngDecCbCtrlStrm
-{
-	vm::bptr<CellPngDecCbControlStream> cbCtrlStrmFunc;
-	be_t<vm::ptr<void>> cbCtrlStrmArg;
-};
-
-struct CellPngDecExtInfo
-{
-	be_t<u64> reserved;
-};
-
-struct CellPngDecExtInParam
-{
-	be_t<CellPngDecBufferMode> bufferMode;
-	be_t<u32> outputCounts;
-	be_t<CellPngDecSpuMode> spuMode;
-};
-
-struct CellPngDecExtOutParam
-{
-	be_t<u64> outputWidthByte;
-	be_t<u32> outputHeight;
-};
-
-struct CellPngDecCbCtrlDisp
-{
-	vm::bptr<CellPngDecCbControlDisp> cbCtrlDispFunc;
-	be_t<vm::ptr<void>> cbCtrlDispArg;
-};
-
-// Functions
-s32 cellPngDecExtOpen(
-	CellPngDecMainHandle mainHandle,
-	vm::ptr<u32> subHandle,
-	vm::ptr<const CellPngDecSrc> src,
-	vm::ptr<CellPngDecOpnInfo> openInfo,
-	vm::ptr<const CellPngDecCbCtrlStrm> cbCtrlStrm,
-	vm::ptr<const CellPngDecOpnParam> opnParam);
-
-s32 cellPngDecExtReadHeader(
-	CellPngDecMainHandle mainHandle,
-	CellPngDecSubHandle subHandle,
-	vm::ptr<CellPngDecInfo> info,
-	vm::ptr<CellPngDecExtInfo> extInfo);
-
-s32 cellPngDecExtSetParameter(
-	CellPngDecMainHandle mainHandle,
-	CellPngDecSubHandle subHandle,
-	vm::ptr<const CellPngDecInParam> inParam,
-	vm::ptr<CellPngDecOutParam> outParam,
-	vm::ptr<const CellPngDecExtInParam> extInParam,
-	vm::ptr<CellPngDecExtOutParam> extOutParam);
-
-s32 cellPngDecExtDecodeData(
-	CellPngDecMainHandle mainHandle,
-	CellPngDecSubHandle subHandle,
-	vm::ptr<u8> data,
-	vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
-	vm::ptr<CellPngDecDataOutInfo> dataOutInfo,
-	vm::ptr<const CellPngDecCbCtrlDisp> cbCtrlDisp,
-	vm::ptr<CellPngDecDispParam> dispParam);
+s32 cellPngDecGetUnknownChunks(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk, vm::ptr<u32> unknownChunkNumber);
 
 // Custom structs
 struct PngDecoder
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSearch.h b/rpcs3/Emu/SysCalls/Modules/cellSearch.h
index 835bea7e9d..8c61d51018 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSearch.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSearch.h
@@ -24,8 +24,6 @@ enum
 	CELL_SEARCH_ERROR_GENERIC               = 0x8002C8FF,
 };
 
-typedef be_t<s32> CellSearchId;
-
 // Constants
 enum
 {
@@ -173,7 +171,7 @@ struct CellSearchContentId
 
 struct CellSearchResultParam
 {
-	be_t<CellSearchId> searchId;
+	be_t<s32> searchId;
 	be_t<u32> resultNum;
 };
 
@@ -271,7 +269,7 @@ struct CellSearchVideoSceneInfo
 	be_t<CellSearchSceneType> sceneType;
 	be_t<s64> startTime_ms;
 	be_t<s64> endTime_ms;
-	be_t<CellSearchContentId> videoId;
+	CellSearchContentId videoId;
 	char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
 	char reserved[3];
 	char tags[CELL_SEARCH_TAG_NUM_MAX][CELL_SEARCH_TAG_LEN_MAX];
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h
index fb84c1f541..f2ef406994 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h
@@ -872,8 +872,8 @@ struct CellSpursTaskInfo
 	const be_t<u32> eaElf_addr; //void *eaElf
 	const be_t<u32> eaContext_addr; //void *eaContext
 	be_t<u32> sizeContext;
-	be_t<u8> state;
-	be_t<u8> hasSignal;
+	u8 state;
+	u8 hasSignal;
 	const be_t<u32> CellSpursTaskExitCode_addr;
 	u8 guid[8];
 	//be_t<u8> reserved[];
diff --git a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
index ca2bd68e5d..69eb7ea158 100644
--- a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
@@ -368,7 +368,7 @@ int cellSurMixerCreate(vm::ptr<const CellSurMixerConfig> config)
 
 					for (auto& p : ssp) if (p.m_active && p.m_created)
 					{
-						auto v = vm::lptrl<s16>::make(p.m_addr); // 16-bit LE audio data
+						auto v = vm::ptrl<s16>::make(p.m_addr); // 16-bit LE audio data
 						float left = 0.0f;
 						float right = 0.0f;
 						float speed = fabs(p.m_speed);
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNpClans.h b/rpcs3/Emu/SysCalls/Modules/sceNpClans.h
index d870d5bd07..838458c071 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNpClans.h
+++ b/rpcs3/Emu/SysCalls/Modules/sceNpClans.h
@@ -108,8 +108,7 @@ enum
 };
 
 // Request handle for clan API
-struct SceNpClansRequest;
-typedef vm::ptr<SceNpClansRequest> SceNpClansRequestHandle;
+using SceNpClansRequestHandle = vm::ptr<struct SceNpClansRequest>;
 
 // Paging request structure
 struct SceNpClansPagingRequest
diff --git a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
index b356d14ada..b916a50550 100644
--- a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
@@ -897,9 +897,20 @@ s32 sys_raw_spu_image_load(s32 id, vm::ptr<sys_spu_image> img)
 	sysPrxForUser.Warning("sys_raw_spu_image_load(id=%d, img=*0x%x)", id, img);
 
 	// TODO: use segment info
+
+	const auto stamp0 = get_system_time();
+
 	memcpy(vm::get_ptr<void>(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id), vm::get_ptr<void>(img->addr), 256 * 1024);
+
+	const auto stamp1 = get_system_time();
+
 	vm::write32(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id + RAW_SPU_PROB_OFFSET + SPU_NPC_offs, img->entry_point | be_t<u32>::make(1));
 
+	const auto stamp2 = get_system_time();
+
+	LOG_ERROR(GENERAL, "memcpy() latency: %lldus", (stamp1 - stamp0));
+	LOG_ERROR(GENERAL, "MMIO latency: %lldus", (stamp2 - stamp1));
+
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/SC_FUNC.h b/rpcs3/Emu/SysCalls/SC_FUNC.h
index 898d1f2220..7ffde175f1 100644
--- a/rpcs3/Emu/SysCalls/SC_FUNC.h
+++ b/rpcs3/Emu/SysCalls/SC_FUNC.h
@@ -136,7 +136,7 @@ namespace ppu_func_detail
 	template <typename RT, typename F, typename Tuple>
 	force_inline RT call(F f, Tuple && t)
 	{
-		typedef typename std::decay<Tuple>::type ttype;
+		using ttype = std::decay_t<Tuple>;
 		return ppu_func_detail::call_impl<RT, F, Tuple, 0 == std::tuple_size<ttype>::value, std::tuple_size<ttype>::value>::call(f, std::forward<Tuple>(t));
 	}