diff --git a/Common/Common.h b/Common/Common.h
index 6271fb0a5c..c5532ca378 100644
--- a/Common/Common.h
+++ b/Common/Common.h
@@ -213,34 +213,6 @@ inline double bswapd( double f )
   return dat2.f;
 }
 
-#ifdef BIG_ENDIAN
-template<typename T> T LE_F(T x) {
-	return (T)bswapf(x);
-}
-template<typename T> T LE_16(T x) {
-	return (T)bswap16(x);
-}
-template<typename T> T LE_32(T x) {
-	return (T)bswap32(x);
-}
-template<typename T> T LE_64(T x) {
-	return (T)bswap64(x);
-}
-#else 
-template<typename T> T LE_F(T x) {
-	return (T)(x);
-}
-template<typename T> T LE_16(T x) {
-	return (T)(x);
-}
-template<typename T> T LE_32(T x) {
-	return (T)(x);
-}
-template<typename T> T LE_64(T x) {
-	return (T)(x);
-}
-#endif
-
 // Host communication.
 enum HOST_COMM
 {
diff --git a/Core/MemMap.h b/Core/MemMap.h
index aaa7e231e3..ad2e76a483 100644
--- a/Core/MemMap.h
+++ b/Core/MemMap.h
@@ -137,17 +137,17 @@ void WriteUnchecked_U32(const u32 _Data, const u32 _Address);
 
 inline u32 ReadUnchecked_U32(const u32 address) {
 #if defined(_M_IX86) || defined(_M_ARM32) || defined (_XBOX)
-  return LE_32(*(u32 *)(base + (address & MEMVIEW32_MASK)));
+  return *(u32_le *)(base + (address & MEMVIEW32_MASK));
 #else
-  return LE_32(*(u32 *)(base + address));
+  return *(u32_le *)(base + address);
 #endif
 }
 
 inline u16 ReadUnchecked_U16(const u32 address) {
 #if defined(_M_IX86) || defined(_M_ARM32) || defined (_XBOX)
-	return LE_16(*(u16 *)(base + (address & MEMVIEW32_MASK)));
+	return *(u16_le *)(base + (address & MEMVIEW32_MASK));
 #else
-	return LE_16(*(u16 *)(base + address));
+	return *(u16_le *)(base + address);
 #endif
 }
 
@@ -161,17 +161,17 @@ inline u8 ReadUnchecked_U8(const u32 address) {
 
 inline void WriteUnchecked_U32(u32 data, u32 address) {
 #if defined(_M_IX86) || defined(_M_ARM32) || defined (_XBOX)
-	(*(u32 *)(base + (address & MEMVIEW32_MASK))) = LE_32(data);
+	*(u32_le *)(base + (address & MEMVIEW32_MASK)) = data;
 #else
-	(*(u32 *)(base + address)) = LE_32(data);
+	*(u32_le *)(base + address) = data;
 #endif
 }
 
 inline void WriteUnchecked_U16(u16 data, u32 address) {
 #if defined(_M_IX86) || defined(_M_ARM32) || defined (_XBOX)
-	(*(u16 *)(base + (address & MEMVIEW32_MASK))) = LE_16(data);
+	*(u16_le *)(base + (address & MEMVIEW32_MASK)) = data;
 #else
-	(*(u16 *)(base + address)) = LE_16(data);
+	*(u16_le *)(base + address) = data;
 #endif
 }
 
diff --git a/Core/MemMapFunctions.cpp b/Core/MemMapFunctions.cpp
index b6958dff32..b6e590b06f 100644
--- a/Core/MemMapFunctions.cpp
+++ b/Core/MemMapFunctions.cpp
@@ -156,23 +156,23 @@ u8 Read_U8(const u32 _Address)
 
 u16 Read_U16(const u32 _Address)
 {
-	u16 _var = 0;
-	ReadFromHardware<u16>(_var, _Address);
-	return (u16)LE_16(_var);
+	u16_le _var = 0;
+	ReadFromHardware<u16_le>(_var, _Address);
+	return (u16)_var;
 }
 
 u32 Read_U32(const u32 _Address)
 {
-	u32 _var = 0;	
-	ReadFromHardware<u32>(_var, _Address);
-	return LE_32(_var);
+	u32_le _var = 0;
+	ReadFromHardware<u32_le>(_var, _Address);
+	return _var;
 }
 
 u64 Read_U64(const u32 _Address)
 {
-	u64 _var = 0;
-	ReadFromHardware<u64>(_var, _Address);
-	return LE_64(_var);
+	u64_le _var = 0;
+	ReadFromHardware<u64_le>(_var, _Address);
+	return _var;
 }
 
 u32 Read_U8_ZX(const u32 _Address)
@@ -190,20 +190,19 @@ void Write_U8(const u8 _Data, const u32 _Address)
 	WriteToHardware<u8>(_Address, _Data);
 }
 
-
 void Write_U16(const u16 _Data, const u32 _Address)
 {
-	WriteToHardware<u16>(_Address, LE_16(_Data));
+	WriteToHardware<u16_le>(_Address, _Data);
 }
 
 void Write_U32(const u32 _Data, const u32 _Address)
 {	
-	WriteToHardware<u32>(_Address, LE_32(_Data));
+	WriteToHardware<u32_le>(_Address, _Data);
 }
 
 void Write_U64(const u64 _Data, const u32 _Address)
 {
-	WriteToHardware<u64>(_Address, LE_64(_Data));
+	WriteToHardware<u64_le>(_Address, _Data);
 }
 
 #ifdef SAFE_MEMORY
@@ -217,16 +216,16 @@ u8 ReadUnchecked_U8(const u32 _Address)
 
 u16 ReadUnchecked_U16(const u32 _Address)
 {
-	u16 _var = 0;
-	ReadFromHardware<u16>(_var, _Address);
-	return LE_16(_var);
+	u16_le _var = 0;
+	ReadFromHardware<u16_le>(_var, _Address);
+	return _var;
 }
 
 u32 ReadUnchecked_U32(const u32 _Address)
 {
-	u32 _var = 0;
-	ReadFromHardware<u32>(_var, _Address);
-	return LE_32(_var);
+	u32_le _var = 0;
+	ReadFromHardware<u32_le>(_var, _Address);
+	return _var;
 }
 
 void WriteUnchecked_U8(const u8 _iValue, const u32 _Address)
@@ -236,12 +235,12 @@ void WriteUnchecked_U8(const u8 _iValue, const u32 _Address)
 
 void WriteUnchecked_U16(const u16 _iValue, const u32 _Address)
 {
-	WriteToHardware<u16>(_Address, LE_16(_iValue));
+	WriteToHardware<u16_le>(_Address, _iValue);
 }
 
 void WriteUnchecked_U32(const u32 _iValue, const u32 _Address)
 {
-	WriteToHardware<u32>(_Address, LE_32(_iValue));
+	WriteToHardware<u32_le>(_Address, _iValue);
 }
 
 #endif