diff --git a/Common/Common.h b/Common/Common.h
index 61eab75ca3..c4b4db067b 100644
--- a/Common/Common.h
+++ b/Common/Common.h
@@ -204,4 +204,6 @@ enum EMUSTATE_CHANGE
 	EMUSTATE_CHANGE_STOP
 };
 
+#include "Swap.h"
+
 #endif // _COMMON_H_
diff --git a/Common/Common.vcxproj b/Common/Common.vcxproj
index 6663b6cb24..0d27075419 100644
--- a/Common/Common.vcxproj
+++ b/Common/Common.vcxproj
@@ -201,6 +201,7 @@
     <ClInclude Include="StdMutex.h" />
     <ClInclude Include="StdThread.h" />
     <ClInclude Include="StringUtils.h" />
+    <ClInclude Include="Swap.h" />
     <ClInclude Include="targetver.h" />
     <ClInclude Include="Thread.h" />
     <ClInclude Include="ThreadPools.h" />
diff --git a/Common/Common.vcxproj.filters b/Common/Common.vcxproj.filters
index 044653e788..3bcc5ae830 100644
--- a/Common/Common.vcxproj.filters
+++ b/Common/Common.vcxproj.filters
@@ -47,6 +47,7 @@
       <Filter>Crypto</Filter>
     </ClInclude>
     <ClInclude Include="KeyMap.h" />
+    <ClInclude Include="Swap.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="stdafx.cpp" />
diff --git a/Common/CommonTypes.h b/Common/CommonTypes.h
index c29aa376e6..59d5814262 100644
--- a/Common/CommonTypes.h
+++ b/Common/CommonTypes.h
@@ -53,504 +53,3 @@ typedef signed int s32;
 typedef signed long long s64;
 
 #endif // _WIN32
-
-// Android
-#if defined(ANDROID)
-#include <sys/endian.h>
-
-#if _BYTE_ORDER == _LITTLE_ENDIAN && !defined(COMMON_LITTLE_ENDIAN)
-#define COMMON_LITTLE_ENDIAN 1
-#elif _BYTE_ORDER == _BIG_ENDIAN && !defined(COMMON_BIG_ENDIAN)
-#define COMMON_BIG_ENDIAN 1
-#endif
-
-// GCC 4.6+
-#elif __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-
-#if __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) && !defined(COMMON_LITTLE_ENDIAN)
-#define COMMON_LITTLE_ENDIAN 1
-#elif __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) && !defined(COMMON_BIG_ENDIAN)
-#define COMMON_BIG_ENDIAN 1
-#endif
-
-// LLVM/clang
-#elif __clang__
-
-#if __LITTLE_ENDIAN__ && !defined(COMMON_LITTLE_ENDIAN)
-#define COMMON_LITTLE_ENDIAN 1
-#elif __BIG_ENDIAN__ && !defined(COMMON_BIG_ENDIAN)
-#define COMMON_BIG_ENDIAN 1
-#endif
-
-// MSVC
-#elif defined(_MSC_VER) && !defined(COMMON_BIG_ENDIAN) && !defined(COMMON_LITTLE_ENDIAN)
-
-#ifdef _XBOX
-#define COMMON_BIG_ENDIAN 1
-#else
-#define COMMON_LITTLE_ENDIAN 1
-#endif
-
-#endif
-
-// Worst case, default to little endian.
-#if !COMMON_BIG_ENDIAN && !COMMON_LITTLE_ENDIAN
-#define COMMON_LITTLE_ENDIAN 1
-#endif
-
-template <typename T, typename F>
-struct swap_struct_t {
-	typedef swap_struct_t<T, F> swapped_t;
-
-protected:
-	T value;
-
-	static T swap(T v) {
-		return F::swap(v);
-	}
-public:
-	T const swap() const {
-		return swap(value);
-
-	}
-	swap_struct_t() :value(0) {}
-	swap_struct_t(const T &v): value(swap(v)) {}
-
-	template <typename S>
-	swapped_t& operator=(const S &source) {
-		value = swap((T)source);
-		return *this;
-	}
-
-	operator long() const { return (long)swap(); }
-	operator s16() const { return (s16)swap(); }
-	operator u16() const { return (u16)swap(); }
-	operator s32() const { return (s32)swap(); }
-	operator u32() const { return (u32)swap(); }
-	operator s64() const { return (s64)swap(); }
-	operator u64() const { return (u64)swap(); }
-	operator float() const { return (float)swap(); }
-	operator double() const { return (double)swap(); }
-
-	// +v
-	swapped_t operator +() const {
-		return +swap();
-	}
-	// -v
-	swapped_t operator -() const {
-		return -swap();
-	}
-
-	// v / 5
-	swapped_t operator/(const swapped_t &i) const {
-		return swap() / i.swap();
-	}
-	template <typename S>
-	swapped_t operator/(const S &i) const {
-		return swap() / i;
-	}
-
-	// v * 5
-	swapped_t operator*(const swapped_t &i) const {
-		return swap() * i.swap();
-	}
-	template <typename S>
-	swapped_t operator*(const S &i) const {
-		return swap() * i;
-	}
-
-	// v + 5
-	swapped_t operator+(const swapped_t &i) const {
-		return swap() + i.swap();
-	}
-	template <typename S>
-	swapped_t operator+(const S &i) const {
-		return swap() + (T)i;
-	}
-	// v - 5
-	swapped_t operator-(const swapped_t &i) const {
-		return swap() - i.swap();
-	}
-	template <typename S>
-	swapped_t operator-(const S &i) const {
-		return swap() - (T)i;
-	}
-
-	// v += 5
-	swapped_t& operator+=(const swapped_t &i) {
-		value = swap(swap() + i.swap());
-		return *this;
-	}
-	template <typename S>
-	swapped_t& operator+=(const S &i) {
-		value = swap(swap() + (T)i);
-		return *this;
-	}
-	// v -= 5
-	swapped_t& operator-=(const swapped_t &i) {
-		value = swap(swap() - i.swap());
-		return *this;
-	}
-	template <typename S>
-	swapped_t& operator-=(const S &i) {
-		value = swap(swap() - (T)i);
-		return *this;
-	}
-
-	// ++v
-	swapped_t& operator++() {
-		value = swap(swap()+1);
-		return *this;
-	}
-	// --v
-	swapped_t& operator--()  {
-		value = swap(swap()-1);
-		return *this;
-	}
-
-	// v++
-	swapped_t operator++(int) {
-		swapped_t old = *this;
-		value = swap(swap()+1);
-		return old;
-	}
-	// v--
-	swapped_t operator--(int) {
-		swapped_t old = *this;
-		value = swap(swap()-1);
-		return old;
-	}
-	// Comparaison
-	// v == i
-	bool operator==(const swapped_t &i) const {
-		return swap() == i.swap();
-	}
-	template <typename S>
-	bool operator==(const S &i) const {
-		return swap() == i;
-	}
-
-	// v != i
-	bool operator!=(const swapped_t &i) const {
-		return swap() != i.swap();
-	}
-	template <typename S>
-	bool operator!=(const S &i) const {
-		return swap() != i;
-	}
-
-	// v > i
-	bool operator>(const swapped_t &i) const {
-		return swap() > i.swap();
-	}
-	template <typename S>
-	bool operator>(const S &i) const {
-		return swap() > i;
-	}
-
-	// v < i
-	bool operator<(const swapped_t &i) const {
-		return swap() < i.swap();
-	}
-	template <typename S>
-	bool operator<(const S &i) const {
-		return swap() < i;
-	}
-
-	// v >= i
-	bool operator>=(const swapped_t &i) const {
-		return swap() >= i.swap();
-	}
-	template <typename S>
-	bool operator>=(const S &i) const {
-		return swap() >= i;
-	}
-
-	// v <= i
-	bool operator<=(const swapped_t &i) const {
-		return swap() <= i.swap();
-	}
-	template <typename S>
-	bool operator<=(const S &i) const {
-		return swap() <= i;
-	}
-
-	// logical
-	swapped_t operator !() const {
-		return !swap();
-	}
-
-	// bitmath
-	swapped_t operator ~() const {
-		return ~swap();
-	}
-
-	swapped_t operator &(const swapped_t &b) const {
-		return swap() & b.swap();
-	}
-	template <typename S>
-	swapped_t operator &(const S &b) const {
-		return swap() & b;
-	}
-	swapped_t& operator &=(const swapped_t &b) {
-		value = swap(swap() & b.swap());
-		return *this;
-	}
-	template <typename S>
-	swapped_t& operator &=(const S b) {
-		value = swap(swap() & b);
-		return *this;
-	}
-
-	swapped_t operator |(const swapped_t &b) const {
-		return swap() | b.swap();
-	}
-	template <typename S>
-	swapped_t operator |(const S &b) const {
-		return swap() | b;
-	}
-	swapped_t& operator |=(const swapped_t &b) {
-		value = swap(swap() | b.swap());
-		return *this;
-	}
-	template <typename S>
-	swapped_t& operator |=(const S &b) {
-		value = swap(swap() | b);
-		return *this;
-	}
-
-	swapped_t operator ^(const swapped_t &b) const {
-		return swap() ^ b.swap();
-	}
-	template <typename S>
-	swapped_t operator ^(const S &b) const {
-		return swap() ^ b;
-	}
-	swapped_t& operator ^=(const swapped_t &b) {
-		value = swap(swap() ^ b.swap());
-		return *this;
-	}
-	template <typename S>
-	swapped_t& operator ^=(const S &b) {
-		value = swap(swap() ^ b);
-		return *this;
-	}
-
-	template <typename S>
-	swapped_t operator <<(const S &b) const {
-		return swap() << b;
-	}
-	template <typename S>
-	swapped_t& operator <<=(const S &b) const {
-		value = swap(swap() << b);
-		return *this;
-	}
-
-	template <typename S>
-	swapped_t operator >>(const S &b) const {
-		return swap() >> b;
-	}
-	template <typename S>
-	swapped_t& operator >>=(const S &b) const {
-		value = swap(swap() >> b);
-		return *this;
-	}
-
-	// Member
-	/** todo **/
-
-
-	// Arithmetics
-	template <typename S, typename T2, typename F2>
-	friend S operator+(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend S operator-(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend S operator/(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend S operator*(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend S operator%(const S &p, const swapped_t v);
-
-	// Arithmetics + assignements
-	template <typename S, typename T2, typename F2>
-	friend S operator+=(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend S operator-=(const S &p, const swapped_t v);
-
-	// Bitmath
-	template <typename S, typename T2, typename F2>
-	friend S operator&(const S &p, const swapped_t v);
-
-	// Comparison
-	template <typename S, typename T2, typename F2>
-	friend bool operator<(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend bool operator>(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend bool operator<=(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend bool operator>=(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend bool operator!=(const S &p, const swapped_t v);
-
-	template <typename S, typename T2, typename F2>
-	friend bool operator==(const S &p, const swapped_t v);
-};
-
-
-// Arithmetics
-template <typename S, typename T, typename F>
-S operator+(const S &i, const swap_struct_t<T, F> v) {
-	return i + v.swap();
-}
-
-template <typename S, typename T, typename F>
-S operator-(const S &i, const swap_struct_t<T, F> v) {
-	return i - v.swap();
-}
-
-template <typename S, typename T, typename F>
-S operator/(const S &i, const swap_struct_t<T, F> v) {
-	return i / v.swap();
-}
-
-template <typename S, typename T, typename F>
-S operator*(const S &i, const swap_struct_t<T, F> v) {
-	return i * v.swap();
-}
-
-template <typename S, typename T, typename F>
-S operator%(const S &i, const swap_struct_t<T, F> v) {
-	return i % v.swap();
-}
-
-// Arithmetics + assignements
-template <typename S, typename T, typename F>
-S &operator+=(S &i, const swap_struct_t<T, F> v) {
-	i += v.swap();
-	return i;
-}
-
-template <typename S, typename T, typename F>
-S &operator-=(S &i, const swap_struct_t<T, F> v) {
-	i -= v.swap();
-	return i;
-}
-
-// Logical
-template <typename S, typename T, typename F>
-S operator&(const S &i, const swap_struct_t<T, F> v) {
-	return i & v.swap();
-}
-
-template <typename S, typename T, typename F>
-S operator&(const swap_struct_t<T, F> v, const S &i) {
-	return (S)(v.swap() & i);
-}
-
-
-// Comparaison
-template <typename S, typename T, typename F>
-bool operator<(const S &p, const swap_struct_t<T, F> v) {
-	return p < v.swap();
-}
-template <typename S, typename T, typename F>
-bool operator>(const S &p, const swap_struct_t<T, F> v) {
-	return p > v.swap();
-}
-template <typename S, typename T, typename F>
-bool operator<=(const S &p, const swap_struct_t<T, F> v) {
-	return p <= v.swap();
-}
-template <typename S, typename T, typename F>
-bool operator>=(const S &p, const swap_struct_t<T, F> v) {
-	return p >= v.swap();
-}
-template <typename S, typename T, typename F>
-bool operator!=(const S &p, const swap_struct_t<T, F> v) {
-	return p != v.swap();
-}
-template <typename S, typename T, typename F>
-bool operator==(const S &p, const swap_struct_t<T, F> v) {
-	return p == v.swap();
-}
-
-template <typename T>
-struct swap_64_t {
-	static T swap(T x) {
-		return (T)bswap64(*(u64 *)&x);
-	}
-};
-
-template <typename T>
-struct swap_32_t {
-	static T swap(T x) {
-		return (T)bswap32(*(u32 *)&x);
-	}
-};
-
-template <typename T>
-struct swap_16_t {
-	static T swap(T x) {
-		return (T)bswap16(*(u16 *)&x);
-	}
-};
-
-#if COMMON_LITTLE_ENDIAN
-typedef u32 u32_le;
-typedef u16 u16_le;
-typedef u64 u64_le;
-
-typedef s32 s32_le;
-typedef s16 s16_le;
-typedef s64 s64_le;
-
-typedef float float_le;
-typedef double double_le;
-
-typedef swap_struct_t<u64, swap_64_t<u64>> u64_be;
-typedef swap_struct_t<s64, swap_64_t<s64>> s64_be;
-
-typedef swap_struct_t<u32, swap_32_t<u32>> u32_be;
-typedef swap_struct_t<s32, swap_32_t<s32>> s32_be;
-
-typedef swap_struct_t<u16, swap_16_t<u32>> u16_be;
-typedef swap_struct_t<s16, swap_16_t<s32>> s16_be;
-
-typedef swap_struct_t<float, swap_32_t<float> > float_be;
-typedef swap_struct_t<double, swap_64_t<double> > double_be;
-#else
-
-typedef swap_struct_t<u64, swap_64_t<u64>> u64_le;
-typedef swap_struct_t<s64, swap_64_t<s64>> s64_le;
-
-typedef swap_struct_t<u32, swap_32_t<u32>> u32_le;
-typedef swap_struct_t<s32, swap_32_t<s32>> s32_le;
-
-typedef swap_struct_t<u16, swap_16_t<u32>> u16_le;
-typedef swap_struct_t<s16, swap_16_t<s32>> s16_le;
-
-typedef swap_struct_t<float, swap_32_t<float> > float_le;
-typedef swap_struct_t<double, swap_64_t<double> > double_le;
-
-typedef u32 u32_be;
-typedef u16 u16_be;
-typedef u64 u64_be;
-
-typedef s32 s32_be;
-typedef s16 s16_be;
-typedef s64 s64_be;
-
-typedef float float_be;
-typedef double double_be;
-#endif
diff --git a/Common/Swap.h b/Common/Swap.h
new file mode 100644
index 0000000000..a94c41cbcf
--- /dev/null
+++ b/Common/Swap.h
@@ -0,0 +1,519 @@
+// Copyright (c) 2012- PPSSPP Project / Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#pragma once
+
+// Android
+#if defined(ANDROID)
+#include <sys/endian.h>
+
+#if _BYTE_ORDER == _LITTLE_ENDIAN && !defined(COMMON_LITTLE_ENDIAN)
+#define COMMON_LITTLE_ENDIAN 1
+#elif _BYTE_ORDER == _BIG_ENDIAN && !defined(COMMON_BIG_ENDIAN)
+#define COMMON_BIG_ENDIAN 1
+#endif
+
+// GCC 4.6+
+#elif __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+
+#if __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) && !defined(COMMON_LITTLE_ENDIAN)
+#define COMMON_LITTLE_ENDIAN 1
+#elif __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) && !defined(COMMON_BIG_ENDIAN)
+#define COMMON_BIG_ENDIAN 1
+#endif
+
+// LLVM/clang
+#elif __clang__
+
+#if __LITTLE_ENDIAN__ && !defined(COMMON_LITTLE_ENDIAN)
+#define COMMON_LITTLE_ENDIAN 1
+#elif __BIG_ENDIAN__ && !defined(COMMON_BIG_ENDIAN)
+#define COMMON_BIG_ENDIAN 1
+#endif
+
+// MSVC
+#elif defined(_MSC_VER) && !defined(COMMON_BIG_ENDIAN) && !defined(COMMON_LITTLE_ENDIAN)
+
+#ifdef _XBOX
+#define COMMON_BIG_ENDIAN 1
+#else
+#define COMMON_LITTLE_ENDIAN 1
+#endif
+
+#endif
+
+// Worst case, default to little endian.
+#if !COMMON_BIG_ENDIAN && !COMMON_LITTLE_ENDIAN
+#define COMMON_LITTLE_ENDIAN 1
+#endif
+
+template <typename T, typename F>
+struct swap_struct_t {
+	typedef swap_struct_t<T, F> swapped_t;
+
+protected:
+	T value;
+
+	static T swap(T v) {
+		return F::swap(v);
+	}
+public:
+	T const swap() const {
+		return swap(value);
+
+	}
+	swap_struct_t() :value(0) {}
+	swap_struct_t(const T &v): value(swap(v)) {}
+
+	template <typename S>
+	swapped_t& operator=(const S &source) {
+		value = swap((T)source);
+		return *this;
+	}
+
+	operator long() const { return (long)swap(); }
+	operator s16() const { return (s16)swap(); }
+	operator u16() const { return (u16)swap(); }
+	operator s32() const { return (s32)swap(); }
+	operator u32() const { return (u32)swap(); }
+	operator s64() const { return (s64)swap(); }
+	operator u64() const { return (u64)swap(); }
+	operator float() const { return (float)swap(); }
+	operator double() const { return (double)swap(); }
+
+	// +v
+	swapped_t operator +() const {
+		return +swap();
+	}
+	// -v
+	swapped_t operator -() const {
+		return -swap();
+	}
+
+	// v / 5
+	swapped_t operator/(const swapped_t &i) const {
+		return swap() / i.swap();
+	}
+	template <typename S>
+	swapped_t operator/(const S &i) const {
+		return swap() / i;
+	}
+
+	// v * 5
+	swapped_t operator*(const swapped_t &i) const {
+		return swap() * i.swap();
+	}
+	template <typename S>
+	swapped_t operator*(const S &i) const {
+		return swap() * i;
+	}
+
+	// v + 5
+	swapped_t operator+(const swapped_t &i) const {
+		return swap() + i.swap();
+	}
+	template <typename S>
+	swapped_t operator+(const S &i) const {
+		return swap() + (T)i;
+	}
+	// v - 5
+	swapped_t operator-(const swapped_t &i) const {
+		return swap() - i.swap();
+	}
+	template <typename S>
+	swapped_t operator-(const S &i) const {
+		return swap() - (T)i;
+	}
+
+	// v += 5
+	swapped_t& operator+=(const swapped_t &i) {
+		value = swap(swap() + i.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator+=(const S &i) {
+		value = swap(swap() + (T)i);
+		return *this;
+	}
+	// v -= 5
+	swapped_t& operator-=(const swapped_t &i) {
+		value = swap(swap() - i.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator-=(const S &i) {
+		value = swap(swap() - (T)i);
+		return *this;
+	}
+
+	// ++v
+	swapped_t& operator++() {
+		value = swap(swap()+1);
+		return *this;
+	}
+	// --v
+	swapped_t& operator--()  {
+		value = swap(swap()-1);
+		return *this;
+	}
+
+	// v++
+	swapped_t operator++(int) {
+		swapped_t old = *this;
+		value = swap(swap()+1);
+		return old;
+	}
+	// v--
+	swapped_t operator--(int) {
+		swapped_t old = *this;
+		value = swap(swap()-1);
+		return old;
+	}
+	// Comparaison
+	// v == i
+	bool operator==(const swapped_t &i) const {
+		return swap() == i.swap();
+	}
+	template <typename S>
+	bool operator==(const S &i) const {
+		return swap() == i;
+	}
+
+	// v != i
+	bool operator!=(const swapped_t &i) const {
+		return swap() != i.swap();
+	}
+	template <typename S>
+	bool operator!=(const S &i) const {
+		return swap() != i;
+	}
+
+	// v > i
+	bool operator>(const swapped_t &i) const {
+		return swap() > i.swap();
+	}
+	template <typename S>
+	bool operator>(const S &i) const {
+		return swap() > i;
+	}
+
+	// v < i
+	bool operator<(const swapped_t &i) const {
+		return swap() < i.swap();
+	}
+	template <typename S>
+	bool operator<(const S &i) const {
+		return swap() < i;
+	}
+
+	// v >= i
+	bool operator>=(const swapped_t &i) const {
+		return swap() >= i.swap();
+	}
+	template <typename S>
+	bool operator>=(const S &i) const {
+		return swap() >= i;
+	}
+
+	// v <= i
+	bool operator<=(const swapped_t &i) const {
+		return swap() <= i.swap();
+	}
+	template <typename S>
+	bool operator<=(const S &i) const {
+		return swap() <= i;
+	}
+
+	// logical
+	swapped_t operator !() const {
+		return !swap();
+	}
+
+	// bitmath
+	swapped_t operator ~() const {
+		return ~swap();
+	}
+
+	swapped_t operator &(const swapped_t &b) const {
+		return swap() & b.swap();
+	}
+	template <typename S>
+	swapped_t operator &(const S &b) const {
+		return swap() & b;
+	}
+	swapped_t& operator &=(const swapped_t &b) {
+		value = swap(swap() & b.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator &=(const S b) {
+		value = swap(swap() & b);
+		return *this;
+	}
+
+	swapped_t operator |(const swapped_t &b) const {
+		return swap() | b.swap();
+	}
+	template <typename S>
+	swapped_t operator |(const S &b) const {
+		return swap() | b;
+	}
+	swapped_t& operator |=(const swapped_t &b) {
+		value = swap(swap() | b.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator |=(const S &b) {
+		value = swap(swap() | b);
+		return *this;
+	}
+
+	swapped_t operator ^(const swapped_t &b) const {
+		return swap() ^ b.swap();
+	}
+	template <typename S>
+	swapped_t operator ^(const S &b) const {
+		return swap() ^ b;
+	}
+	swapped_t& operator ^=(const swapped_t &b) {
+		value = swap(swap() ^ b.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator ^=(const S &b) {
+		value = swap(swap() ^ b);
+		return *this;
+	}
+
+	template <typename S>
+	swapped_t operator <<(const S &b) const {
+		return swap() << b;
+	}
+	template <typename S>
+	swapped_t& operator <<=(const S &b) const {
+		value = swap(swap() << b);
+		return *this;
+	}
+
+	template <typename S>
+	swapped_t operator >>(const S &b) const {
+		return swap() >> b;
+	}
+	template <typename S>
+	swapped_t& operator >>=(const S &b) const {
+		value = swap(swap() >> b);
+		return *this;
+	}
+
+	// Member
+	/** todo **/
+
+
+	// Arithmetics
+	template <typename S, typename T2, typename F2>
+	friend S operator+(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend S operator-(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend S operator/(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend S operator*(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend S operator%(const S &p, const swapped_t v);
+
+	// Arithmetics + assignements
+	template <typename S, typename T2, typename F2>
+	friend S operator+=(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend S operator-=(const S &p, const swapped_t v);
+
+	// Bitmath
+	template <typename S, typename T2, typename F2>
+	friend S operator&(const S &p, const swapped_t v);
+
+	// Comparison
+	template <typename S, typename T2, typename F2>
+	friend bool operator<(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend bool operator>(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend bool operator<=(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend bool operator>=(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend bool operator!=(const S &p, const swapped_t v);
+
+	template <typename S, typename T2, typename F2>
+	friend bool operator==(const S &p, const swapped_t v);
+};
+
+
+// Arithmetics
+template <typename S, typename T, typename F>
+S operator+(const S &i, const swap_struct_t<T, F> v) {
+	return i + v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator-(const S &i, const swap_struct_t<T, F> v) {
+	return i - v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator/(const S &i, const swap_struct_t<T, F> v) {
+	return i / v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator*(const S &i, const swap_struct_t<T, F> v) {
+	return i * v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator%(const S &i, const swap_struct_t<T, F> v) {
+	return i % v.swap();
+}
+
+// Arithmetics + assignements
+template <typename S, typename T, typename F>
+S &operator+=(S &i, const swap_struct_t<T, F> v) {
+	i += v.swap();
+	return i;
+}
+
+template <typename S, typename T, typename F>
+S &operator-=(S &i, const swap_struct_t<T, F> v) {
+	i -= v.swap();
+	return i;
+}
+
+// Logical
+template <typename S, typename T, typename F>
+S operator&(const S &i, const swap_struct_t<T, F> v) {
+	return i & v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator&(const swap_struct_t<T, F> v, const S &i) {
+	return (S)(v.swap() & i);
+}
+
+
+// Comparaison
+template <typename S, typename T, typename F>
+bool operator<(const S &p, const swap_struct_t<T, F> v) {
+	return p < v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator>(const S &p, const swap_struct_t<T, F> v) {
+	return p > v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator<=(const S &p, const swap_struct_t<T, F> v) {
+	return p <= v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator>=(const S &p, const swap_struct_t<T, F> v) {
+	return p >= v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator!=(const S &p, const swap_struct_t<T, F> v) {
+	return p != v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator==(const S &p, const swap_struct_t<T, F> v) {
+	return p == v.swap();
+}
+
+template <typename T>
+struct swap_64_t {
+	static T swap(T x) {
+		return (T)bswap64(*(u64 *)&x);
+	}
+};
+
+template <typename T>
+struct swap_32_t {
+	static T swap(T x) {
+		return (T)bswap32(*(u32 *)&x);
+	}
+};
+
+template <typename T>
+struct swap_16_t {
+	static T swap(T x) {
+		return (T)bswap16(*(u16 *)&x);
+	}
+};
+
+#if COMMON_LITTLE_ENDIAN
+typedef u32 u32_le;
+typedef u16 u16_le;
+typedef u64 u64_le;
+
+typedef s32 s32_le;
+typedef s16 s16_le;
+typedef s64 s64_le;
+
+typedef float float_le;
+typedef double double_le;
+
+typedef swap_struct_t<u64, swap_64_t<u64>> u64_be;
+typedef swap_struct_t<s64, swap_64_t<s64>> s64_be;
+
+typedef swap_struct_t<u32, swap_32_t<u32>> u32_be;
+typedef swap_struct_t<s32, swap_32_t<s32>> s32_be;
+
+typedef swap_struct_t<u16, swap_16_t<u32>> u16_be;
+typedef swap_struct_t<s16, swap_16_t<s32>> s16_be;
+
+typedef swap_struct_t<float, swap_32_t<float> > float_be;
+typedef swap_struct_t<double, swap_64_t<double> > double_be;
+#else
+
+typedef swap_struct_t<u64, swap_64_t<u64>> u64_le;
+typedef swap_struct_t<s64, swap_64_t<s64>> s64_le;
+
+typedef swap_struct_t<u32, swap_32_t<u32>> u32_le;
+typedef swap_struct_t<s32, swap_32_t<s32>> s32_le;
+
+typedef swap_struct_t<u16, swap_16_t<u32>> u16_le;
+typedef swap_struct_t<s16, swap_16_t<s32>> s16_le;
+
+typedef swap_struct_t<float, swap_32_t<float> > float_le;
+typedef swap_struct_t<double, swap_64_t<double> > double_le;
+
+typedef u32 u32_be;
+typedef u16 u16_be;
+typedef u64 u64_be;
+
+typedef s32 s32_be;
+typedef s16 s16_be;
+typedef s64 s64_be;
+
+typedef float float_be;
+typedef double double_be;
+#endif
\ No newline at end of file