diff --git a/README.md b/README.md
index 735c9a46db..37eb72f3d3 100644
--- a/README.md
+++ b/README.md
@@ -5,17 +5,25 @@ An open-source PlayStation 3 emulator/debugger written in C++.
 
 You can find some basic information in the [FAQ](https://github.com/DHrpcs3/rpcs3/wiki/FAQ). For discussion about this emulator and PS3 emulation please visit the [official forums](http://www.emunewz.net/forum/forumdisplay.php?fid=162).
 
-### Dependencies
-
-* [Visual C++ Redistributable Packages for Visual Studio 2013](http://www.microsoft.com/en-us/download/details.aspx?id=40784)
-* [OpenAL32.dll](http://www.mediafire.com/?nwt3ilty2mo)
 
 ### Development
 
 If you want to contribute please take a took at the [Coding Style](https://github.com/DHrpcs3/rpcs3/wiki/Coding-Style), [Roadmap](https://github.com/DHrpcs3/rpcs3/wiki/Roadmap) and [Developer Information](https://github.com/DHrpcs3/rpcs3/wiki/Developer-Information) pages. You should as well contact any of the developers in the forum in order to know about the current situation of the emulator.
 
+
+### Dependencies
+
+__Windows__
+* [Visual C++ Redistributable Packages for Visual Studio 2013](http://www.microsoft.com/en-us/download/details.aspx?id=40784)
+* [OpenAL32.dll](http://www.mediafire.com/?nwt3ilty2mo)
+
+__Linux__
+* Debian & Ubuntu: `sudo apt-get install libopenal-dev libwxgtk3.0-dev build-essential`
+
+
 ### Building
 
 To initialize the repository don't forget to execute `git submodule update --init` to pull the wxWidgets source.
 * __Windows__: Install *Visual Studio 2013*. Then open the *.SLN* file, and press *Build* > *Rebuild Solution*.
-* __Linux__: *TODO*
+* __Linux__:
+`cd rpcs3 && cmake CMakeLists.txt && make && cd ../` Then run with `cd bin && ./rpcs3`
diff --git a/Utilities/Array.h b/Utilities/Array.h
index ad5e715d7d..0855fdbdc7 100644
--- a/Utilities/Array.h
+++ b/Utilities/Array.h
@@ -1,228 +1,5 @@
 #pragma once
 
-template<typename T> class Array
-{
-protected:
-	u32 m_count;
-	T* m_array;
-
-public:
-	Array()
-		: m_count(0)
-		, m_array(NULL)
-	{
-	}
-
-	~Array()
-	{
-		Clear();
-	}
-
-	inline bool RemoveAt(const u32 from, const u32 count = 1)
-	{
-		if(!GetCount()) return false;
-		const u32 to = from + count;
-		if(to > GetCount()) return false;
-		
-		for(u32 i=0; i<count; ++i) m_array[from + i].~T();
-		memmove(m_array + from, m_array + to, (m_count-to) * sizeof(T));
-		m_count -= count;
-		
-		return true;
-	}
-	
-	void InsertRoomEnd(const u32 size)
-	{
-		_InsertRoomEnd(size);
-	}
-	
-	bool InsertRoom(const u32 pos, const u32 size)
-	{
-		if(pos >= m_count) return false;
-		
-		_InsertRoomEnd(size);
-		memmove(m_array + pos + size, m_array + pos, sizeof(T) * (m_count - size - pos));
-
-		return true;
-	}
-
-	inline bool Move(const u32 pos, T* data)
-	{
-		if(!InsertRoom(pos, 1)) return false;
-		
-		memcpy(m_array + pos, data, sizeof(T));
-		free(data);
-		
-		return true;
-	}
-
-	inline u32 Move(T* data)
-	{
-		_InsertRoomEnd(1);
-
-		memcpy(m_array + GetCount() - 1, data, sizeof(T));
-		free(data);
-
-		return m_count - 1;
-	}
-
-	inline bool Add(const u32 pos, T*& data)
-	{
-		if(!InsertRoom(pos, 1)) return false;
-		
-		memcpy(m_array + pos, data, sizeof(T));
-		free(data);
-		data = m_array + pos;
-		
-		return true;
-	}
-
-	inline u32 Add(T*& data)
-	{
-		_InsertRoomEnd(1);
-
-		memcpy(m_array + GetCount() - 1, data, sizeof(T));
-		free(data);
-		data = m_array + GetCount() - 1;
-		
-		return m_count - 1;
-	}
-
-	inline bool AddCpy(const u32 pos, const T* data, u32 count = 1)
-	{
-		if(!InsertRoom(pos, count)) return false;
-		
-		for(u32 i=0; i<count; ++i)
-		{
-			new (m_array + pos + i) T(data[i]);
-		}
-
-		return true;
-	}
-
-	inline bool AddCpy(const u32 pos, const T& data)
-	{
-		return AddCpy(pos, &data);
-	}
-
-	inline u32 AddCpy(const T* data, u32 count = 1)
-	{
-		_InsertRoomEnd(count);
-
-		for(u32 i=0; i<count; ++i)
-		{
-			new (m_array + m_count - count + i) T(data[i]);
-		}
-
-		return m_count - count;
-	}
-
-	inline u32 AddCpy(const T& data)
-	{
-		return AddCpy(&data);
-	}
-
-	inline void Clear()
-	{
-		u32 count = m_count;
-		m_count = 0;
-		for(u32 i=0; i<count; ++i) m_array[i].~T();
-		safe_free(m_array);
-	}
-
-	inline void ClearF()
-	{
-		m_count = 0;
-		safe_free(m_array);
-	}
-
-	inline T& Get(u32 num)
-	{
-		//if(num >= GetCount()) return *new T();
-		return m_array[num];
-	}
-
-	u32 GetCount() const { return m_count; }
-
-	void SetCount(const u32 count, bool memzero = true)
-	{
-		if(m_count >= count) return;
-
-		_InsertRoomEnd(count - m_count);
-
-		if(memzero) memset(m_array + m_count - count, 0, sizeof(T) * (m_count - count));
-	}
-
-	void Reserve(const u32 count)
-	{
-		SetCount(GetCount() + count);
-	}
-
-	void AppendFrom(const Array<T>& src)
-	{
-		if(!src.GetCount()) return;
-
-		Reserve(src.GetCount());
-
-		memcpy(m_array, &src[0], GetCount() * sizeof(T));
-	}
-
-	void CopyFrom(const Array<T>& src)
-	{
-		Clear();
-
-		AppendFrom(src);
-	}
-
-	inline T* GetPtr() { return m_array; }
-	inline const T* GetPtr() const { return m_array; }
-
-	T& operator[](u32 num) const { return m_array[num]; }
-	
-	T* operator + (u32 right) const
-	{
-		return m_array + right;
-	}
-
-	T* operator ->()
-	{
-		return m_array;
-	}
-
-protected:	
-	void _InsertRoomEnd(const u32 size)
-	{
-		if(!size) return;
-
-		m_array = m_count ? (T*)realloc(m_array, sizeof(T) * (m_count + size)) : (T*)malloc(sizeof(T) * size);
-		m_count += size;
-	}
-};
-
-template<typename T> struct Stack : public Array<T>
-{
-	Stack() : Array<T>()
-	{
-	}
-
-	~Stack()
-	{
-		Array<T>::Clear();
-	}
-
-	void Push(const T data) { Array<T>::AddCpy(data); }
-
-	T Pop()
-	{
-		const u32 pos = Array<T>::GetCount() - 1;
-
-		const T ret = Array<T>::Get(pos);
-		Array<T>::RemoveAt(pos);
-
-		return ret;
-	}
-};
-
 template<typename T, size_t size> class SizedStack
 {
 	T m_ptr[size];
@@ -278,106 +55,6 @@ public:
 	}
 };
 
-template<typename T> class ArrayF
-{
-	u32 m_count;
-	T** m_array;
-
-public:
-	ArrayF()
-		: m_count(0)
-		, m_array(NULL)
-	{
-	}
-
-	virtual ~ArrayF()
-	{
-		Clear();
-	}
-
-	inline bool RemoveFAt(const u32 from, const u32 count = 1)
-	{
-		if(from + count > m_count) return false;
-
-		memmove(&m_array[from], &m_array[from+count], (m_count-(from+count)) * sizeof(T**));
-
-		m_count -= count;
-		return true;
-	}
-
-	inline bool RemoveAt(const u32 from, const u32 count = 1)
-	{
-		if(from + count > m_count) return false;
-
-		for(uint i = from; i < from + count; ++i)
-		{
-			free(m_array[i]);
-		}
-
-		return RemoveFAt(from, count);
-	}
-
-	inline u32 Add(T& data)
-	{
-		return Add(&data);
-	}
-
-	inline u32 Add(T* data)
-	{
-		if(!m_array)
-		{
-			m_array = (T**)malloc(sizeof(T*));
-		}
-		else
-		{
-			m_array = (T**)realloc(m_array, sizeof(T*) * (m_count + 1));
-		}
-
-		m_array[m_count] = data;
-		return m_count++;
-	}
-
-	inline void ClearF()
-	{
-		if(m_count == 0) return;
-
-		m_count = 0;
-		m_array = NULL;
-	}
-
-	inline void Clear()
-	{
-		if(m_count == 0) return;
-
-		m_count = 0;
-		safe_free(m_array);
-	}
-
-	inline T& Get(const u64 num)
-	{
-		//if(m_count <= num) *m_array[0]; //TODO
-		return *m_array[num];
-	}
-
-	T** operator + (u32 right) const
-	{
-		return m_array + right;
-	}
-
-	T* operator ->()
-	{
-		return *m_array;
-	}
-
-	inline T** GetPtr()
-	{
-		return m_array;
-	}
-
-	inline u32 GetCount() const { return m_count; }
-	T& operator[](u32 num) const { return *m_array[num]; }
-};
-
 template<typename T> struct ScopedPtr
 {
 private:
diff --git a/Utilities/BEType.h b/Utilities/BEType.h
index 02c47ed76d..853fd32dec 100644
--- a/Utilities/BEType.h
+++ b/Utilities/BEType.h
@@ -57,17 +57,18 @@ public:
 	be_t()	noexcept = default;
 #endif
 
+	be_t(const be_t<T,size>& value) = default;
 	be_t(const T& value)
 	{
 		FromLE(value);
 	}
 
 	template<typename T1>
-	be_t(const be_t<T1>& value)
+	explicit be_t(const be_t<T1>& value)
 	{
 		FromBE(value.ToBE());
 	}
-
+	
 	const T& ToBE() const
 	{
 		return m_data;
@@ -126,11 +127,7 @@ public:
 		return *this;
 	}
 
-	be_t& operator = (const be_t& right)
-	{
-		m_data = right.m_data;
-		return *this;
-	}
+	be_t<T,size>& operator = (const be_t<T,size>& right) = default;
 
 	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; }
diff --git a/Utilities/GNU.h b/Utilities/GNU.h
index e928c1ee6f..9d0ba8abb2 100644
--- a/Utilities/GNU.h
+++ b/Utilities/GNU.h
@@ -2,6 +2,9 @@
 
 #if defined(__GNUG__)
 #include <cmath>
+#include <stdlib.h>
+#include <malloc.h>
+
 #define _fpclass(x) std::fpclassify(x)
 #define __forceinline __attribute__((always_inline))
 #define _byteswap_ushort(x) __builtin_bswap16(x)
@@ -13,7 +16,8 @@
 #define _CRT_ALIGN(x) __attribute__((aligned(x)))
 #define InterlockedCompareExchange(ptr,new_val,old_val)  __sync_val_compare_and_swap(ptr,old_val,new_val)
 #define InterlockedCompareExchange64(ptr,new_val,old_val)  __sync_val_compare_and_swap(ptr,old_val,new_val)
-#define _aligned_malloc(size,alignment) aligned_alloc(alignment,size)
-#define _aligned_free(pointer)  free(pointer)
+#define _aligned_malloc(size,alignment) memalign(alignment,size)
+#define _aligned_free  free
 #define DWORD int32_t
 #endif
+
diff --git a/Utilities/IdManager.h b/Utilities/IdManager.h
index 9ceb8ae66e..45d0d09970 100644
--- a/Utilities/IdManager.h
+++ b/Utilities/IdManager.h
@@ -50,6 +50,14 @@ struct ID
 	{
 	}
 
+	ID(ID&& other)
+	{
+		m_name = other.m_name;
+		m_attr = other.m_attr;
+		m_data = other.m_data;
+		other.m_data = nullptr;
+	}
+
 	void Kill()
 	{
 		delete m_data;
diff --git a/Utilities/Thread.cpp b/Utilities/Thread.cpp
index b71fc5eeea..940e6b94e9 100644
--- a/Utilities/Thread.cpp
+++ b/Utilities/Thread.cpp
@@ -35,6 +35,8 @@ ThreadBase::~ThreadBase()
 {
 	if(IsAlive())
 		Stop(false);
+
+	safe_delete(m_executor);
 }
 
 void ThreadBase::Start()
diff --git a/Utilities/Thread.h b/Utilities/Thread.h
index da04de0051..cba6bcbdf3 100644
--- a/Utilities/Thread.h
+++ b/Utilities/Thread.h
@@ -2,6 +2,7 @@
 #include "Array.h"
 #include <functional>
 #include <thread>
+#include <vector>
 #include <mutex>
 #include <atomic>
 #include <condition_variable>
@@ -73,7 +74,7 @@ template<typename T> class MTPacketBuffer
 protected:
 	volatile bool m_busy;
 	volatile u32 m_put, m_get;
-	Array<u8> m_buffer;
+	std::vector<u8> m_buffer;
 	u32 m_max_buffer_size;
 	mutable std::recursive_mutex m_cs_main;
 
@@ -98,7 +99,7 @@ public:
 	{
 		std::lock_guard<std::recursive_mutex> lock(m_cs_main);
 		m_put = m_get = 0;
-		m_buffer.Clear();
+		m_buffer.clear();
 		m_busy = false;
 	}
 
diff --git a/rpcs3.sln b/rpcs3.sln
index ea7660aef6..2a23107f36 100644
--- a/rpcs3.sln
+++ b/rpcs3.sln
@@ -84,12 +84,18 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "asmjit", "asmjit.vcxproj",
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug - MemLeak|Win32 = Debug - MemLeak|Win32
+		Debug - MemLeak|x64 = Debug - MemLeak|x64
 		Debug|Win32 = Debug|Win32
 		Debug|x64 = Debug|x64
 		Release|Win32 = Release|Win32
 		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug - MemLeak|Win32.ActiveCfg = Debug - MemLeak|Win32
+		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug - MemLeak|Win32.Build.0 = Debug - MemLeak|Win32
+		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug - MemLeak|x64.ActiveCfg = Debug - MemLeak|x64
+		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug - MemLeak|x64.Build.0 = Debug - MemLeak|x64
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug|Win32.ActiveCfg = Debug|Win32
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug|Win32.Build.0 = Debug|Win32
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug|x64.ActiveCfg = Debug|x64
@@ -98,6 +104,10 @@ Global
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Release|Win32.Build.0 = Release|Win32
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Release|x64.ActiveCfg = Release|x64
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Release|x64.Build.0 = Release|x64
+		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug|Win32.ActiveCfg = Debug|Win32
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug|Win32.Build.0 = Debug|Win32
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug|x64.ActiveCfg = Debug|x64
@@ -106,6 +116,10 @@ Global
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Release|Win32.Build.0 = Release|Win32
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Release|x64.ActiveCfg = Release|x64
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Release|x64.Build.0 = Release|x64
+		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug|Win32.ActiveCfg = Debug|Win32
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug|Win32.Build.0 = Debug|Win32
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug|x64.ActiveCfg = Debug|x64
@@ -114,6 +128,10 @@ Global
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Release|Win32.Build.0 = Release|Win32
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Release|x64.ActiveCfg = Release|x64
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Release|x64.Build.0 = Release|x64
+		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug|Win32.ActiveCfg = Debug|Win32
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug|Win32.Build.0 = Debug|Win32
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug|x64.ActiveCfg = Debug|x64
@@ -122,6 +140,10 @@ Global
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Release|Win32.Build.0 = Release|Win32
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Release|x64.ActiveCfg = Release|x64
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Release|x64.Build.0 = Release|x64
+		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug|Win32.ActiveCfg = Debug|Win32
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug|Win32.Build.0 = Debug|Win32
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug|x64.ActiveCfg = Debug|x64
@@ -130,6 +152,10 @@ Global
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Release|Win32.Build.0 = Release|Win32
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Release|x64.ActiveCfg = Release|x64
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Release|x64.Build.0 = Release|x64
+		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug|Win32.ActiveCfg = Debug|Win32
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug|Win32.Build.0 = Debug|Win32
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug|x64.ActiveCfg = Debug|x64
@@ -138,6 +164,10 @@ Global
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Release|Win32.Build.0 = Release|Win32
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Release|x64.ActiveCfg = Release|x64
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Release|x64.Build.0 = Release|x64
+		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug|Win32.ActiveCfg = Debug|Win32
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug|Win32.Build.0 = Debug|Win32
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug|x64.ActiveCfg = Debug|x64
@@ -146,6 +176,10 @@ Global
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Release|Win32.Build.0 = Release|Win32
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Release|x64.ActiveCfg = Release|x64
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Release|x64.Build.0 = Release|x64
+		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug|Win32.ActiveCfg = Debug|Win32
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug|Win32.Build.0 = Debug|Win32
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug|x64.ActiveCfg = Debug|x64
@@ -154,6 +188,10 @@ Global
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Release|Win32.Build.0 = Release|Win32
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Release|x64.ActiveCfg = Release|x64
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Release|x64.Build.0 = Release|x64
+		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug|Win32.ActiveCfg = Debug|Win32
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug|Win32.Build.0 = Debug|Win32
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug|x64.ActiveCfg = Debug|x64
@@ -162,6 +200,10 @@ Global
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Release|Win32.Build.0 = Release|Win32
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Release|x64.ActiveCfg = Release|x64
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Release|x64.Build.0 = Release|x64
+		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug|Win32.ActiveCfg = Debug|Win32
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug|Win32.Build.0 = Debug|Win32
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug|x64.ActiveCfg = Debug|x64
@@ -170,6 +212,10 @@ Global
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Release|Win32.Build.0 = Release|Win32
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Release|x64.ActiveCfg = Release|x64
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Release|x64.Build.0 = Release|x64
+		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug|Win32.ActiveCfg = Debug|Win32
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug|Win32.Build.0 = Debug|Win32
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug|x64.ActiveCfg = Debug|x64
@@ -178,6 +224,10 @@ Global
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Release|Win32.Build.0 = Release|Win32
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Release|x64.ActiveCfg = Release|x64
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Release|x64.Build.0 = Release|x64
+		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug|Win32.ActiveCfg = Debug|Win32
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug|Win32.Build.0 = Debug|Win32
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug|x64.ActiveCfg = Debug|x64
@@ -186,6 +236,10 @@ Global
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Release|Win32.Build.0 = Release|Win32
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Release|x64.ActiveCfg = Release|x64
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Release|x64.Build.0 = Release|x64
+		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug|Win32.ActiveCfg = Debug|Win32
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug|Win32.Build.0 = Debug|Win32
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug|x64.ActiveCfg = Debug|x64
@@ -194,6 +248,10 @@ Global
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Release|Win32.Build.0 = Release|Win32
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Release|x64.ActiveCfg = Release|x64
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Release|x64.Build.0 = Release|x64
+		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug|Win32.ActiveCfg = Debug|Win32
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug|Win32.Build.0 = Debug|Win32
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug|x64.ActiveCfg = Debug|x64
@@ -202,6 +260,10 @@ Global
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Release|Win32.Build.0 = Release|Win32
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Release|x64.ActiveCfg = Release|x64
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Release|x64.Build.0 = Release|x64
+		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug|Win32.ActiveCfg = Debug|Win32
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug|Win32.Build.0 = Debug|Win32
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug|x64.ActiveCfg = Debug|x64
@@ -210,6 +272,10 @@ Global
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Release|Win32.Build.0 = Release|Win32
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Release|x64.ActiveCfg = Release|x64
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Release|x64.Build.0 = Release|x64
+		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug|Win32.ActiveCfg = Debug|Win32
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug|Win32.Build.0 = Debug|Win32
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug|x64.ActiveCfg = Debug|x64
@@ -218,6 +284,10 @@ Global
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Release|Win32.Build.0 = Release|Win32
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Release|x64.ActiveCfg = Release|x64
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Release|x64.Build.0 = Release|x64
+		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug|Win32.ActiveCfg = Debug|Win32
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug|Win32.Build.0 = Debug|Win32
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug|x64.ActiveCfg = Debug|x64
@@ -226,6 +296,10 @@ Global
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Release|Win32.Build.0 = Release|Win32
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Release|x64.ActiveCfg = Release|x64
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Release|x64.Build.0 = Release|x64
+		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug|Win32.ActiveCfg = Debug|Win32
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug|Win32.Build.0 = Debug|Win32
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug|x64.ActiveCfg = Debug|x64
@@ -234,6 +308,10 @@ Global
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Release|Win32.Build.0 = Release|Win32
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Release|x64.ActiveCfg = Release|x64
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Release|x64.Build.0 = Release|x64
+		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug|Win32.ActiveCfg = Debug|Win32
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug|Win32.Build.0 = Debug|Win32
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug|x64.ActiveCfg = Debug|x64
@@ -242,6 +320,10 @@ Global
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Release|Win32.Build.0 = Release|Win32
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Release|x64.ActiveCfg = Release|x64
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Release|x64.Build.0 = Release|x64
+		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug|Win32.ActiveCfg = Debug|Win32
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug|Win32.Build.0 = Debug|Win32
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug|x64.ActiveCfg = Debug|x64
@@ -250,6 +332,10 @@ Global
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Release|Win32.Build.0 = Release|Win32
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Release|x64.ActiveCfg = Release|x64
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Release|x64.Build.0 = Release|x64
+		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug|Win32.ActiveCfg = Debug|Win32
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug|Win32.Build.0 = Debug|Win32
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug|x64.ActiveCfg = Debug|x64
@@ -258,6 +344,10 @@ Global
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Release|Win32.Build.0 = Release|Win32
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Release|x64.ActiveCfg = Release|x64
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Release|x64.Build.0 = Release|x64
+		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug|Win32.ActiveCfg = Debug|Win32
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug|Win32.Build.0 = Debug|Win32
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug|x64.ActiveCfg = Debug|x64
@@ -266,6 +356,10 @@ Global
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Release|Win32.Build.0 = Release|Win32
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Release|x64.ActiveCfg = Release|x64
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Release|x64.Build.0 = Release|x64
+		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug - MemLeak|Win32.Build.0 = Debug|Win32
+		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
+		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug - MemLeak|x64.Build.0 = Debug|x64
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug|Win32.ActiveCfg = Debug|Win32
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug|Win32.Build.0 = Debug|Win32
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug|x64.ActiveCfg = Debug|x64
@@ -274,6 +368,8 @@ Global
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Release|Win32.Build.0 = Release|Win32
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Release|x64.ActiveCfg = Release|x64
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Release|x64.Build.0 = Release|x64
+		{AC40FF01-426E-4838-A317-66354CEFAE88}.Debug - MemLeak|Win32.ActiveCfg = Debug|Win32
+		{AC40FF01-426E-4838-A317-66354CEFAE88}.Debug - MemLeak|x64.ActiveCfg = Debug|x64
 		{AC40FF01-426E-4838-A317-66354CEFAE88}.Debug|Win32.ActiveCfg = Debug|Win32
 		{AC40FF01-426E-4838-A317-66354CEFAE88}.Debug|Win32.Build.0 = Debug|Win32
 		{AC40FF01-426E-4838-A317-66354CEFAE88}.Debug|x64.ActiveCfg = Debug|x64
diff --git a/rpcs3/AppConnector.cpp b/rpcs3/AppConnector.cpp
index b38ccd67c8..212965ee2f 100644
--- a/rpcs3/AppConnector.cpp
+++ b/rpcs3/AppConnector.cpp
@@ -3,21 +3,21 @@
 
 AppConnector::~AppConnector()
 {
-	for(uint i=0; i<m_connect_arr.GetCount(); ++i)
+	for(auto& connection : m_connect_arr)
 	{
 		wxGetApp().Disconnect(
-			m_connect_arr[i].winid,
-			m_connect_arr[i].lastId,
-			m_connect_arr[i].eventType,
-			m_connect_arr[i].func,
-			m_connect_arr[i].userData,
-			m_connect_arr[i].eventSink);
+			connection.winid,
+			connection.lastId,
+			connection.eventType,
+			connection.func,
+			connection.userData,
+			connection.eventSink);
 	}
 }
 
 void AppConnector::Connect(int winid, int lastId, int eventType, wxObjectEventFunction func, wxObject* userData, wxEvtHandler* eventSink)
 {
-	m_connect_arr.Move(new ConnectInfo(winid, lastId, eventType, func, userData, eventSink));
+	m_connect_arr.emplace_back(winid, lastId, eventType, func, userData, eventSink);
 	wxGetApp().Connect(winid, lastId, eventType, func, userData, eventSink);
 }
 
@@ -29,4 +29,4 @@ void AppConnector::Connect(int winid, int eventType, wxObjectEventFunction func,
 void AppConnector::Connect(int eventType, wxObjectEventFunction func, wxObject* userData, wxEvtHandler* eventSink)
 {
 	Connect(wxID_ANY, wxID_ANY, eventType, func, userData, eventSink);
-}
\ No newline at end of file
+}
diff --git a/rpcs3/AppConnector.h b/rpcs3/AppConnector.h
index 26bf26dd4e..93067c3524 100644
--- a/rpcs3/AppConnector.h
+++ b/rpcs3/AppConnector.h
@@ -22,7 +22,7 @@ class AppConnector
 		}
 	};
 
-	Array<ConnectInfo> m_connect_arr;
+	std::vector<ConnectInfo> m_connect_arr;
 
 public:
 	~AppConnector();
@@ -30,4 +30,4 @@ public:
 	void Connect(int winid, int lastId, int eventType, wxObjectEventFunction func, wxObject* userData = nullptr, wxEvtHandler* eventSink = nullptr);
 	void Connect(int winid, int eventType, wxObjectEventFunction func, wxObject* userData = nullptr, wxEvtHandler* eventSink = nullptr);
 	void Connect(int eventType, wxObjectEventFunction func, wxObject* userData = nullptr, wxEvtHandler* eventSink = nullptr);
-};
\ No newline at end of file
+};
diff --git a/rpcs3/CMakeLists.txt b/rpcs3/CMakeLists.txt
index 9bece62c40..843d9ce382 100644
--- a/rpcs3/CMakeLists.txt
+++ b/rpcs3/CMakeLists.txt
@@ -11,7 +11,7 @@ if (CMAKE_COMPILER_IS_GNUCXX)
 	add_definitions(-msse2)
 endif()
 
-set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules)
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules")
 set(EXECUTABLE_OUTPUT_PATH "${CMAKE_SOURCE_DIR}/../bin")
 
 add_definitions(-DGL_GLEXT_PROTOTYPES)
@@ -34,28 +34,28 @@ endif()
 include_directories(
 ${wxWidgets_INCLUDE_DIRS}
 ${OPENAL_INCLUDE_DIR}
-${CMAKE_SOURCE_DIR}/../ffmpeg/${PLATFORM_ARCH}/include
-${CMAKE_SOURCE_DIR}
-${CMAKE_SOURCE_DIR}/Emu
-${CMAKE_SOURCE_DIR}/Gui
-${CMAKE_SOURCE_DIR}/Loader
-${CMAKE_SOURCE_DIR}/Crypto
-${CMAKE_SOURCE_DIR}/..
+"${CMAKE_SOURCE_DIR}/../ffmpeg/${PLATFORM_ARCH}/include"
+"${CMAKE_SOURCE_DIR}"
+"${CMAKE_SOURCE_DIR}/Emu"
+"${CMAKE_SOURCE_DIR}/Gui"
+"${CMAKE_SOURCE_DIR}/Loader"
+"${CMAKE_SOURCE_DIR}/Crypto"
+"${CMAKE_SOURCE_DIR}/.."
 )
 
-link_directories(${CMAKE_SOURCE_DIR}/../ffmpeg/${PLATFORM_ARCH}/lib)
+link_directories("${CMAKE_SOURCE_DIR}/../ffmpeg/${PLATFORM_ARCH}/lib")
 
 file(
 GLOB_RECURSE
 RPCS3_SRC
-${CMAKE_SOURCE_DIR}/rpcs3.cpp
-${CMAKE_SOURCE_DIR}/AppConnector.cpp
-${CMAKE_SOURCE_DIR}/Ini.cpp
-${CMAKE_SOURCE_DIR}/Emu/*
-${CMAKE_SOURCE_DIR}/Gui/*
-${CMAKE_SOURCE_DIR}/Loader/*
-${CMAKE_SOURCE_DIR}/Crypto/*
-${CMAKE_SOURCE_DIR}/../Utilities/*
+"${CMAKE_SOURCE_DIR}/rpcs3.cpp"
+"${CMAKE_SOURCE_DIR}/AppConnector.cpp"
+"${CMAKE_SOURCE_DIR}/Ini.cpp"
+"${CMAKE_SOURCE_DIR}/Emu/*"
+"${CMAKE_SOURCE_DIR}/Gui/*"
+"${CMAKE_SOURCE_DIR}/Loader/*"
+"${CMAKE_SOURCE_DIR}/Crypto/*"
+"${CMAKE_SOURCE_DIR}/../Utilities/*"
 )
 
 add_executable(rpcs3 ${RPCS3_SRC})
diff --git a/rpcs3/Crypto/aes.cpp b/rpcs3/Crypto/aes.cpp
index 8b411732e0..cfadf23c50 100644
--- a/rpcs3/Crypto/aes.cpp
+++ b/rpcs3/Crypto/aes.cpp
@@ -1,865 +1,865 @@
-/*
- *  FIPS-197 compliant AES implementation
- *
- *  Copyright (C) 2006-2013, Brainspark B.V.
- *
- *  This file is part of PolarSSL (http://www.polarssl.org)
- *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
- *
- *  All rights reserved.
- *
- *  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; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  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 for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-/*
- *  The AES block cipher was designed by Vincent Rijmen and Joan Daemen.
- *
- *  http://csrc.nist.gov/encryption/aes/rijndael/Rijndael.pdf
- *  http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
- */
-
-#include "stdafx.h"
-#include "aes.h"
-
-/*
- * 32-bit integer manipulation macros (little endian)
- */
-#ifndef GET_UINT32_LE
-#define GET_UINT32_LE(n,b,i)                            \
-{                                                       \
-    (n) = ( (uint32_t) (b)[(i)    ]       )             \
-        | ( (uint32_t) (b)[(i) + 1] <<  8 )             \
-        | ( (uint32_t) (b)[(i) + 2] << 16 )             \
-        | ( (uint32_t) (b)[(i) + 3] << 24 );            \
-}
-#endif
-
-#ifndef PUT_UINT32_LE
-#define PUT_UINT32_LE(n,b,i)                            \
-{                                                       \
-    (b)[(i)    ] = (unsigned char) ( (n)       );       \
-    (b)[(i) + 1] = (unsigned char) ( (n) >>  8 );       \
-    (b)[(i) + 2] = (unsigned char) ( (n) >> 16 );       \
-    (b)[(i) + 3] = (unsigned char) ( (n) >> 24 );       \
-}
-#endif
-
-#if defined(POLARSSL_AES_ROM_TABLES)
-/*
- * Forward S-box
- */
-static const unsigned char FSb[256] =
-{
-    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
-    0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
-    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
-    0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
-    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
-    0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
-    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
-    0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
-    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
-    0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
-    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
-    0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
-    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,
-    0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
-    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
-    0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
-    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
-    0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
-    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,
-    0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
-    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
-    0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
-    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,
-    0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
-    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
-    0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
-    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
-    0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
-    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,
-    0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
-    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,
-    0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
-};
-
-/*
- * Forward tables
- */
-#define FT \
-\
-    V(A5,63,63,C6), V(84,7C,7C,F8), V(99,77,77,EE), V(8D,7B,7B,F6), \
-    V(0D,F2,F2,FF), V(BD,6B,6B,D6), V(B1,6F,6F,DE), V(54,C5,C5,91), \
-    V(50,30,30,60), V(03,01,01,02), V(A9,67,67,CE), V(7D,2B,2B,56), \
-    V(19,FE,FE,E7), V(62,D7,D7,B5), V(E6,AB,AB,4D), V(9A,76,76,EC), \
-    V(45,CA,CA,8F), V(9D,82,82,1F), V(40,C9,C9,89), V(87,7D,7D,FA), \
-    V(15,FA,FA,EF), V(EB,59,59,B2), V(C9,47,47,8E), V(0B,F0,F0,FB), \
-    V(EC,AD,AD,41), V(67,D4,D4,B3), V(FD,A2,A2,5F), V(EA,AF,AF,45), \
-    V(BF,9C,9C,23), V(F7,A4,A4,53), V(96,72,72,E4), V(5B,C0,C0,9B), \
-    V(C2,B7,B7,75), V(1C,FD,FD,E1), V(AE,93,93,3D), V(6A,26,26,4C), \
-    V(5A,36,36,6C), V(41,3F,3F,7E), V(02,F7,F7,F5), V(4F,CC,CC,83), \
-    V(5C,34,34,68), V(F4,A5,A5,51), V(34,E5,E5,D1), V(08,F1,F1,F9), \
-    V(93,71,71,E2), V(73,D8,D8,AB), V(53,31,31,62), V(3F,15,15,2A), \
-    V(0C,04,04,08), V(52,C7,C7,95), V(65,23,23,46), V(5E,C3,C3,9D), \
-    V(28,18,18,30), V(A1,96,96,37), V(0F,05,05,0A), V(B5,9A,9A,2F), \
-    V(09,07,07,0E), V(36,12,12,24), V(9B,80,80,1B), V(3D,E2,E2,DF), \
-    V(26,EB,EB,CD), V(69,27,27,4E), V(CD,B2,B2,7F), V(9F,75,75,EA), \
-    V(1B,09,09,12), V(9E,83,83,1D), V(74,2C,2C,58), V(2E,1A,1A,34), \
-    V(2D,1B,1B,36), V(B2,6E,6E,DC), V(EE,5A,5A,B4), V(FB,A0,A0,5B), \
-    V(F6,52,52,A4), V(4D,3B,3B,76), V(61,D6,D6,B7), V(CE,B3,B3,7D), \
-    V(7B,29,29,52), V(3E,E3,E3,DD), V(71,2F,2F,5E), V(97,84,84,13), \
-    V(F5,53,53,A6), V(68,D1,D1,B9), V(00,00,00,00), V(2C,ED,ED,C1), \
-    V(60,20,20,40), V(1F,FC,FC,E3), V(C8,B1,B1,79), V(ED,5B,5B,B6), \
-    V(BE,6A,6A,D4), V(46,CB,CB,8D), V(D9,BE,BE,67), V(4B,39,39,72), \
-    V(DE,4A,4A,94), V(D4,4C,4C,98), V(E8,58,58,B0), V(4A,CF,CF,85), \
-    V(6B,D0,D0,BB), V(2A,EF,EF,C5), V(E5,AA,AA,4F), V(16,FB,FB,ED), \
-    V(C5,43,43,86), V(D7,4D,4D,9A), V(55,33,33,66), V(94,85,85,11), \
-    V(CF,45,45,8A), V(10,F9,F9,E9), V(06,02,02,04), V(81,7F,7F,FE), \
-    V(F0,50,50,A0), V(44,3C,3C,78), V(BA,9F,9F,25), V(E3,A8,A8,4B), \
-    V(F3,51,51,A2), V(FE,A3,A3,5D), V(C0,40,40,80), V(8A,8F,8F,05), \
-    V(AD,92,92,3F), V(BC,9D,9D,21), V(48,38,38,70), V(04,F5,F5,F1), \
-    V(DF,BC,BC,63), V(C1,B6,B6,77), V(75,DA,DA,AF), V(63,21,21,42), \
-    V(30,10,10,20), V(1A,FF,FF,E5), V(0E,F3,F3,FD), V(6D,D2,D2,BF), \
-    V(4C,CD,CD,81), V(14,0C,0C,18), V(35,13,13,26), V(2F,EC,EC,C3), \
-    V(E1,5F,5F,BE), V(A2,97,97,35), V(CC,44,44,88), V(39,17,17,2E), \
-    V(57,C4,C4,93), V(F2,A7,A7,55), V(82,7E,7E,FC), V(47,3D,3D,7A), \
-    V(AC,64,64,C8), V(E7,5D,5D,BA), V(2B,19,19,32), V(95,73,73,E6), \
-    V(A0,60,60,C0), V(98,81,81,19), V(D1,4F,4F,9E), V(7F,DC,DC,A3), \
-    V(66,22,22,44), V(7E,2A,2A,54), V(AB,90,90,3B), V(83,88,88,0B), \
-    V(CA,46,46,8C), V(29,EE,EE,C7), V(D3,B8,B8,6B), V(3C,14,14,28), \
-    V(79,DE,DE,A7), V(E2,5E,5E,BC), V(1D,0B,0B,16), V(76,DB,DB,AD), \
-    V(3B,E0,E0,DB), V(56,32,32,64), V(4E,3A,3A,74), V(1E,0A,0A,14), \
-    V(DB,49,49,92), V(0A,06,06,0C), V(6C,24,24,48), V(E4,5C,5C,B8), \
-    V(5D,C2,C2,9F), V(6E,D3,D3,BD), V(EF,AC,AC,43), V(A6,62,62,C4), \
-    V(A8,91,91,39), V(A4,95,95,31), V(37,E4,E4,D3), V(8B,79,79,F2), \
-    V(32,E7,E7,D5), V(43,C8,C8,8B), V(59,37,37,6E), V(B7,6D,6D,DA), \
-    V(8C,8D,8D,01), V(64,D5,D5,B1), V(D2,4E,4E,9C), V(E0,A9,A9,49), \
-    V(B4,6C,6C,D8), V(FA,56,56,AC), V(07,F4,F4,F3), V(25,EA,EA,CF), \
-    V(AF,65,65,CA), V(8E,7A,7A,F4), V(E9,AE,AE,47), V(18,08,08,10), \
-    V(D5,BA,BA,6F), V(88,78,78,F0), V(6F,25,25,4A), V(72,2E,2E,5C), \
-    V(24,1C,1C,38), V(F1,A6,A6,57), V(C7,B4,B4,73), V(51,C6,C6,97), \
-    V(23,E8,E8,CB), V(7C,DD,DD,A1), V(9C,74,74,E8), V(21,1F,1F,3E), \
-    V(DD,4B,4B,96), V(DC,BD,BD,61), V(86,8B,8B,0D), V(85,8A,8A,0F), \
-    V(90,70,70,E0), V(42,3E,3E,7C), V(C4,B5,B5,71), V(AA,66,66,CC), \
-    V(D8,48,48,90), V(05,03,03,06), V(01,F6,F6,F7), V(12,0E,0E,1C), \
-    V(A3,61,61,C2), V(5F,35,35,6A), V(F9,57,57,AE), V(D0,B9,B9,69), \
-    V(91,86,86,17), V(58,C1,C1,99), V(27,1D,1D,3A), V(B9,9E,9E,27), \
-    V(38,E1,E1,D9), V(13,F8,F8,EB), V(B3,98,98,2B), V(33,11,11,22), \
-    V(BB,69,69,D2), V(70,D9,D9,A9), V(89,8E,8E,07), V(A7,94,94,33), \
-    V(B6,9B,9B,2D), V(22,1E,1E,3C), V(92,87,87,15), V(20,E9,E9,C9), \
-    V(49,CE,CE,87), V(FF,55,55,AA), V(78,28,28,50), V(7A,DF,DF,A5), \
-    V(8F,8C,8C,03), V(F8,A1,A1,59), V(80,89,89,09), V(17,0D,0D,1A), \
-    V(DA,BF,BF,65), V(31,E6,E6,D7), V(C6,42,42,84), V(B8,68,68,D0), \
-    V(C3,41,41,82), V(B0,99,99,29), V(77,2D,2D,5A), V(11,0F,0F,1E), \
-    V(CB,B0,B0,7B), V(FC,54,54,A8), V(D6,BB,BB,6D), V(3A,16,16,2C)
-
-#define V(a,b,c,d) 0x##a##b##c##d
-static const uint32_t FT0[256] = { FT };
-#undef V
-
-#define V(a,b,c,d) 0x##b##c##d##a
-static const uint32_t FT1[256] = { FT };
-#undef V
-
-#define V(a,b,c,d) 0x##c##d##a##b
-static const uint32_t FT2[256] = { FT };
-#undef V
-
-#define V(a,b,c,d) 0x##d##a##b##c
-static const uint32_t FT3[256] = { FT };
-#undef V
-
-#undef FT
-
-/*
- * Reverse S-box
- */
-static const unsigned char RSb[256] =
-{
-    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
-    0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
-    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
-    0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
-    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,
-    0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
-    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,
-    0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
-    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
-    0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
-    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
-    0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
-    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,
-    0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
-    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
-    0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
-    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,
-    0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
-    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,
-    0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
-    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
-    0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
-    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,
-    0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
-    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,
-    0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
-    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
-    0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
-    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,
-    0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
-    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,
-    0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
-};
-
-/*
- * Reverse tables
- */
-#define RT \
-\
-    V(50,A7,F4,51), V(53,65,41,7E), V(C3,A4,17,1A), V(96,5E,27,3A), \
-    V(CB,6B,AB,3B), V(F1,45,9D,1F), V(AB,58,FA,AC), V(93,03,E3,4B), \
-    V(55,FA,30,20), V(F6,6D,76,AD), V(91,76,CC,88), V(25,4C,02,F5), \
-    V(FC,D7,E5,4F), V(D7,CB,2A,C5), V(80,44,35,26), V(8F,A3,62,B5), \
-    V(49,5A,B1,DE), V(67,1B,BA,25), V(98,0E,EA,45), V(E1,C0,FE,5D), \
-    V(02,75,2F,C3), V(12,F0,4C,81), V(A3,97,46,8D), V(C6,F9,D3,6B), \
-    V(E7,5F,8F,03), V(95,9C,92,15), V(EB,7A,6D,BF), V(DA,59,52,95), \
-    V(2D,83,BE,D4), V(D3,21,74,58), V(29,69,E0,49), V(44,C8,C9,8E), \
-    V(6A,89,C2,75), V(78,79,8E,F4), V(6B,3E,58,99), V(DD,71,B9,27), \
-    V(B6,4F,E1,BE), V(17,AD,88,F0), V(66,AC,20,C9), V(B4,3A,CE,7D), \
-    V(18,4A,DF,63), V(82,31,1A,E5), V(60,33,51,97), V(45,7F,53,62), \
-    V(E0,77,64,B1), V(84,AE,6B,BB), V(1C,A0,81,FE), V(94,2B,08,F9), \
-    V(58,68,48,70), V(19,FD,45,8F), V(87,6C,DE,94), V(B7,F8,7B,52), \
-    V(23,D3,73,AB), V(E2,02,4B,72), V(57,8F,1F,E3), V(2A,AB,55,66), \
-    V(07,28,EB,B2), V(03,C2,B5,2F), V(9A,7B,C5,86), V(A5,08,37,D3), \
-    V(F2,87,28,30), V(B2,A5,BF,23), V(BA,6A,03,02), V(5C,82,16,ED), \
-    V(2B,1C,CF,8A), V(92,B4,79,A7), V(F0,F2,07,F3), V(A1,E2,69,4E), \
-    V(CD,F4,DA,65), V(D5,BE,05,06), V(1F,62,34,D1), V(8A,FE,A6,C4), \
-    V(9D,53,2E,34), V(A0,55,F3,A2), V(32,E1,8A,05), V(75,EB,F6,A4), \
-    V(39,EC,83,0B), V(AA,EF,60,40), V(06,9F,71,5E), V(51,10,6E,BD), \
-    V(F9,8A,21,3E), V(3D,06,DD,96), V(AE,05,3E,DD), V(46,BD,E6,4D), \
-    V(B5,8D,54,91), V(05,5D,C4,71), V(6F,D4,06,04), V(FF,15,50,60), \
-    V(24,FB,98,19), V(97,E9,BD,D6), V(CC,43,40,89), V(77,9E,D9,67), \
-    V(BD,42,E8,B0), V(88,8B,89,07), V(38,5B,19,E7), V(DB,EE,C8,79), \
-    V(47,0A,7C,A1), V(E9,0F,42,7C), V(C9,1E,84,F8), V(00,00,00,00), \
-    V(83,86,80,09), V(48,ED,2B,32), V(AC,70,11,1E), V(4E,72,5A,6C), \
-    V(FB,FF,0E,FD), V(56,38,85,0F), V(1E,D5,AE,3D), V(27,39,2D,36), \
-    V(64,D9,0F,0A), V(21,A6,5C,68), V(D1,54,5B,9B), V(3A,2E,36,24), \
-    V(B1,67,0A,0C), V(0F,E7,57,93), V(D2,96,EE,B4), V(9E,91,9B,1B), \
-    V(4F,C5,C0,80), V(A2,20,DC,61), V(69,4B,77,5A), V(16,1A,12,1C), \
-    V(0A,BA,93,E2), V(E5,2A,A0,C0), V(43,E0,22,3C), V(1D,17,1B,12), \
-    V(0B,0D,09,0E), V(AD,C7,8B,F2), V(B9,A8,B6,2D), V(C8,A9,1E,14), \
-    V(85,19,F1,57), V(4C,07,75,AF), V(BB,DD,99,EE), V(FD,60,7F,A3), \
-    V(9F,26,01,F7), V(BC,F5,72,5C), V(C5,3B,66,44), V(34,7E,FB,5B), \
-    V(76,29,43,8B), V(DC,C6,23,CB), V(68,FC,ED,B6), V(63,F1,E4,B8), \
-    V(CA,DC,31,D7), V(10,85,63,42), V(40,22,97,13), V(20,11,C6,84), \
-    V(7D,24,4A,85), V(F8,3D,BB,D2), V(11,32,F9,AE), V(6D,A1,29,C7), \
-    V(4B,2F,9E,1D), V(F3,30,B2,DC), V(EC,52,86,0D), V(D0,E3,C1,77), \
-    V(6C,16,B3,2B), V(99,B9,70,A9), V(FA,48,94,11), V(22,64,E9,47), \
-    V(C4,8C,FC,A8), V(1A,3F,F0,A0), V(D8,2C,7D,56), V(EF,90,33,22), \
-    V(C7,4E,49,87), V(C1,D1,38,D9), V(FE,A2,CA,8C), V(36,0B,D4,98), \
-    V(CF,81,F5,A6), V(28,DE,7A,A5), V(26,8E,B7,DA), V(A4,BF,AD,3F), \
-    V(E4,9D,3A,2C), V(0D,92,78,50), V(9B,CC,5F,6A), V(62,46,7E,54), \
-    V(C2,13,8D,F6), V(E8,B8,D8,90), V(5E,F7,39,2E), V(F5,AF,C3,82), \
-    V(BE,80,5D,9F), V(7C,93,D0,69), V(A9,2D,D5,6F), V(B3,12,25,CF), \
-    V(3B,99,AC,C8), V(A7,7D,18,10), V(6E,63,9C,E8), V(7B,BB,3B,DB), \
-    V(09,78,26,CD), V(F4,18,59,6E), V(01,B7,9A,EC), V(A8,9A,4F,83), \
-    V(65,6E,95,E6), V(7E,E6,FF,AA), V(08,CF,BC,21), V(E6,E8,15,EF), \
-    V(D9,9B,E7,BA), V(CE,36,6F,4A), V(D4,09,9F,EA), V(D6,7C,B0,29), \
-    V(AF,B2,A4,31), V(31,23,3F,2A), V(30,94,A5,C6), V(C0,66,A2,35), \
-    V(37,BC,4E,74), V(A6,CA,82,FC), V(B0,D0,90,E0), V(15,D8,A7,33), \
-    V(4A,98,04,F1), V(F7,DA,EC,41), V(0E,50,CD,7F), V(2F,F6,91,17), \
-    V(8D,D6,4D,76), V(4D,B0,EF,43), V(54,4D,AA,CC), V(DF,04,96,E4), \
-    V(E3,B5,D1,9E), V(1B,88,6A,4C), V(B8,1F,2C,C1), V(7F,51,65,46), \
-    V(04,EA,5E,9D), V(5D,35,8C,01), V(73,74,87,FA), V(2E,41,0B,FB), \
-    V(5A,1D,67,B3), V(52,D2,DB,92), V(33,56,10,E9), V(13,47,D6,6D), \
-    V(8C,61,D7,9A), V(7A,0C,A1,37), V(8E,14,F8,59), V(89,3C,13,EB), \
-    V(EE,27,A9,CE), V(35,C9,61,B7), V(ED,E5,1C,E1), V(3C,B1,47,7A), \
-    V(59,DF,D2,9C), V(3F,73,F2,55), V(79,CE,14,18), V(BF,37,C7,73), \
-    V(EA,CD,F7,53), V(5B,AA,FD,5F), V(14,6F,3D,DF), V(86,DB,44,78), \
-    V(81,F3,AF,CA), V(3E,C4,68,B9), V(2C,34,24,38), V(5F,40,A3,C2), \
-    V(72,C3,1D,16), V(0C,25,E2,BC), V(8B,49,3C,28), V(41,95,0D,FF), \
-    V(71,01,A8,39), V(DE,B3,0C,08), V(9C,E4,B4,D8), V(90,C1,56,64), \
-    V(61,84,CB,7B), V(70,B6,32,D5), V(74,5C,6C,48), V(42,57,B8,D0)
-
-#define V(a,b,c,d) 0x##a##b##c##d
-static const uint32_t RT0[256] = { RT };
-#undef V
-
-#define V(a,b,c,d) 0x##b##c##d##a
-static const uint32_t RT1[256] = { RT };
-#undef V
-
-#define V(a,b,c,d) 0x##c##d##a##b
-static const uint32_t RT2[256] = { RT };
-#undef V
-
-#define V(a,b,c,d) 0x##d##a##b##c
-static const uint32_t RT3[256] = { RT };
-#undef V
-
-#undef RT
-
-/*
- * Round constants
- */
-static const uint32_t RCON[10] =
-{
-    0x00000001, 0x00000002, 0x00000004, 0x00000008,
-    0x00000010, 0x00000020, 0x00000040, 0x00000080,
-    0x0000001B, 0x00000036
-};
-
-#else
-
-/*
- * Forward S-box & tables
- */
-static unsigned char FSb[256];
-static uint32_t FT0[256]; 
-static uint32_t FT1[256]; 
-static uint32_t FT2[256]; 
-static uint32_t FT3[256]; 
-
-/*
- * Reverse S-box & tables
- */
-static unsigned char RSb[256];
-static uint32_t RT0[256];
-static uint32_t RT1[256];
-static uint32_t RT2[256];
-static uint32_t RT3[256];
-
-/*
- * Round constants
- */
-static uint32_t RCON[10];
-
-/*
- * Tables generation code
- */
-#define ROTL8(x) ( ( x << 8 ) & 0xFFFFFFFF ) | ( x >> 24 )
-#define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )
-#define MUL(x,y) ( ( x && y ) ? pow[(log[x]+log[y]) % 255] : 0 )
-
-static int aes_init_done = 0;
-
-static void aes_gen_tables( void )
-{
-    int i, x, y, z;
-    int pow[256];
-    int log[256];
-
-    /*
-     * compute pow and log tables over GF(2^8)
-     */
-    for( i = 0, x = 1; i < 256; i++ )
-    {
-        pow[i] = x;
-        log[x] = i;
-        x = ( x ^ XTIME( x ) ) & 0xFF;
-    }
-
-    /*
-     * calculate the round constants
-     */
-    for( i = 0, x = 1; i < 10; i++ )
-    {
-        RCON[i] = (uint32_t) x;
-        x = XTIME( x ) & 0xFF;
-    }
-
-    /*
-     * generate the forward and reverse S-boxes
-     */
-    FSb[0x00] = 0x63;
-    RSb[0x63] = 0x00;
-
-    for( i = 1; i < 256; i++ )
-    {
-        x = pow[255 - log[i]];
-
-        y  = x; y = ( (y << 1) | (y >> 7) ) & 0xFF;
-        x ^= y; y = ( (y << 1) | (y >> 7) ) & 0xFF;
-        x ^= y; y = ( (y << 1) | (y >> 7) ) & 0xFF;
-        x ^= y; y = ( (y << 1) | (y >> 7) ) & 0xFF;
-        x ^= y ^ 0x63;
-
-        FSb[i] = (unsigned char) x;
-        RSb[x] = (unsigned char) i;
-    }
-
-    /*
-     * generate the forward and reverse tables
-     */
-    for( i = 0; i < 256; i++ )
-    {
-        x = FSb[i];
-        y = XTIME( x ) & 0xFF;
-        z =  ( y ^ x ) & 0xFF;
-
-        FT0[i] = ( (uint32_t) y       ) ^
-                 ( (uint32_t) x <<  8 ) ^
-                 ( (uint32_t) x << 16 ) ^
-                 ( (uint32_t) z << 24 );
-
-        FT1[i] = ROTL8( FT0[i] );
-        FT2[i] = ROTL8( FT1[i] );
-        FT3[i] = ROTL8( FT2[i] );
-
-        x = RSb[i];
-
-        RT0[i] = ( (uint32_t) MUL( 0x0E, x )       ) ^
-                 ( (uint32_t) MUL( 0x09, x ) <<  8 ) ^
-                 ( (uint32_t) MUL( 0x0D, x ) << 16 ) ^
-                 ( (uint32_t) MUL( 0x0B, x ) << 24 );
-
-        RT1[i] = ROTL8( RT0[i] );
-        RT2[i] = ROTL8( RT1[i] );
-        RT3[i] = ROTL8( RT2[i] );
-    }
-}
-
-#endif
-
-/*
- * AES key schedule (encryption)
- */
-int aes_setkey_enc( aes_context *ctx, const unsigned char *key, unsigned int keysize )
-{
-    unsigned int i;
-    uint32_t *RK;
-
-#if !defined(POLARSSL_AES_ROM_TABLES)
-    if( aes_init_done == 0 )
-    {
-        aes_gen_tables();
-        aes_init_done = 1;
-
-    }
-#endif
-
-    switch( keysize )
-    {
-        case 128: ctx->nr = 10; break;
-        case 192: ctx->nr = 12; break;
-        case 256: ctx->nr = 14; break;
-        default : return( POLARSSL_ERR_AES_INVALID_KEY_LENGTH );
-    }
-
-    ctx->rk = RK = ctx->buf;
-
-    for( i = 0; i < (keysize >> 5); i++ )
-    {
-        GET_UINT32_LE( RK[i], key, i << 2 );
-    }
-
-    switch( ctx->nr )
-    {
-        case 10:
-
-            for( i = 0; i < 10; i++, RK += 4 )
-            {
-                RK[4]  = RK[0] ^ RCON[i] ^
-                ( (uint32_t) FSb[ ( RK[3] >>  8 ) & 0xFF ]       ) ^
-                ( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) FSb[ ( RK[3]       ) & 0xFF ] << 24 );
-
-                RK[5]  = RK[1] ^ RK[4];
-                RK[6]  = RK[2] ^ RK[5];
-                RK[7]  = RK[3] ^ RK[6];
-            }
-            break;
-
-        case 12:
-
-            for( i = 0; i < 8; i++, RK += 6 )
-            {
-                RK[6]  = RK[0] ^ RCON[i] ^
-                ( (uint32_t) FSb[ ( RK[5] >>  8 ) & 0xFF ]       ) ^
-                ( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) FSb[ ( RK[5]       ) & 0xFF ] << 24 );
-
-                RK[7]  = RK[1] ^ RK[6];
-                RK[8]  = RK[2] ^ RK[7];
-                RK[9]  = RK[3] ^ RK[8];
-                RK[10] = RK[4] ^ RK[9];
-                RK[11] = RK[5] ^ RK[10];
-            }
-            break;
-
-        case 14:
-
-            for( i = 0; i < 7; i++, RK += 8 )
-            {
-                RK[8]  = RK[0] ^ RCON[i] ^
-                ( (uint32_t) FSb[ ( RK[7] >>  8 ) & 0xFF ]       ) ^
-                ( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) FSb[ ( RK[7]       ) & 0xFF ] << 24 );
-
-                RK[9]  = RK[1] ^ RK[8];
-                RK[10] = RK[2] ^ RK[9];
-                RK[11] = RK[3] ^ RK[10];
-
-                RK[12] = RK[4] ^
-                ( (uint32_t) FSb[ ( RK[11]       ) & 0xFF ]       ) ^
-                ( (uint32_t) FSb[ ( RK[11] >>  8 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
-
-                RK[13] = RK[5] ^ RK[12];
-                RK[14] = RK[6] ^ RK[13];
-                RK[15] = RK[7] ^ RK[14];
-            }
-            break;
-
-        default:
-
-            break;
-    }
-
-    return( 0 );
-}
-
-/*
- * AES key schedule (decryption)
- */
-int aes_setkey_dec( aes_context *ctx, const unsigned char *key, unsigned int keysize )
-{
-    int i, j;
-    aes_context cty;
-    uint32_t *RK;
-    uint32_t *SK;
-    int ret;
-
-    switch( keysize )
-    {
-        case 128: ctx->nr = 10; break;
-        case 192: ctx->nr = 12; break;
-        case 256: ctx->nr = 14; break;
-        default : return( POLARSSL_ERR_AES_INVALID_KEY_LENGTH );
-    }
-
-    ctx->rk = RK = ctx->buf;
-
-    ret = aes_setkey_enc( &cty, key, keysize );
-    if( ret != 0 )
-        return( ret );
-
-    SK = cty.rk + cty.nr * 4;
-
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-
-    for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
-    {
-        for( j = 0; j < 4; j++, SK++ )
-        {
-            *RK++ = RT0[ FSb[ ( *SK       ) & 0xFF ] ] ^
-                    RT1[ FSb[ ( *SK >>  8 ) & 0xFF ] ] ^
-                    RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
-                    RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ];
-        }
-    }
-
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-    *RK++ = *SK++;
-
-    memset( &cty, 0, sizeof( aes_context ) );
-
-    return( 0 );
-}
-
-#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
-{                                               \
-    X0 = *RK++ ^ FT0[ ( Y0       ) & 0xFF ] ^   \
-                 FT1[ ( Y1 >>  8 ) & 0xFF ] ^   \
-                 FT2[ ( Y2 >> 16 ) & 0xFF ] ^   \
-                 FT3[ ( Y3 >> 24 ) & 0xFF ];    \
-                                                \
-    X1 = *RK++ ^ FT0[ ( Y1       ) & 0xFF ] ^   \
-                 FT1[ ( Y2 >>  8 ) & 0xFF ] ^   \
-                 FT2[ ( Y3 >> 16 ) & 0xFF ] ^   \
-                 FT3[ ( Y0 >> 24 ) & 0xFF ];    \
-                                                \
-    X2 = *RK++ ^ FT0[ ( Y2       ) & 0xFF ] ^   \
-                 FT1[ ( Y3 >>  8 ) & 0xFF ] ^   \
-                 FT2[ ( Y0 >> 16 ) & 0xFF ] ^   \
-                 FT3[ ( Y1 >> 24 ) & 0xFF ];    \
-                                                \
-    X3 = *RK++ ^ FT0[ ( Y3       ) & 0xFF ] ^   \
-                 FT1[ ( Y0 >>  8 ) & 0xFF ] ^   \
-                 FT2[ ( Y1 >> 16 ) & 0xFF ] ^   \
-                 FT3[ ( Y2 >> 24 ) & 0xFF ];    \
-}
-
-#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
-{                                               \
-    X0 = *RK++ ^ RT0[ ( Y0       ) & 0xFF ] ^   \
-                 RT1[ ( Y3 >>  8 ) & 0xFF ] ^   \
-                 RT2[ ( Y2 >> 16 ) & 0xFF ] ^   \
-                 RT3[ ( Y1 >> 24 ) & 0xFF ];    \
-                                                \
-    X1 = *RK++ ^ RT0[ ( Y1       ) & 0xFF ] ^   \
-                 RT1[ ( Y0 >>  8 ) & 0xFF ] ^   \
-                 RT2[ ( Y3 >> 16 ) & 0xFF ] ^   \
-                 RT3[ ( Y2 >> 24 ) & 0xFF ];    \
-                                                \
-    X2 = *RK++ ^ RT0[ ( Y2       ) & 0xFF ] ^   \
-                 RT1[ ( Y1 >>  8 ) & 0xFF ] ^   \
-                 RT2[ ( Y0 >> 16 ) & 0xFF ] ^   \
-                 RT3[ ( Y3 >> 24 ) & 0xFF ];    \
-                                                \
-    X3 = *RK++ ^ RT0[ ( Y3       ) & 0xFF ] ^   \
-                 RT1[ ( Y2 >>  8 ) & 0xFF ] ^   \
-                 RT2[ ( Y1 >> 16 ) & 0xFF ] ^   \
-                 RT3[ ( Y0 >> 24 ) & 0xFF ];    \
-}
-
-/*
- * AES-ECB block encryption/decryption
- */
-int aes_crypt_ecb( aes_context *ctx,
-                    int mode,
-                    const unsigned char input[16],
-                    unsigned char output[16] )
-{
-    int i;
-    uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
-
-    RK = ctx->rk;
-
-    GET_UINT32_LE( X0, input,  0 ); X0 ^= *RK++;
-    GET_UINT32_LE( X1, input,  4 ); X1 ^= *RK++;
-    GET_UINT32_LE( X2, input,  8 ); X2 ^= *RK++;
-    GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
-
-    if( mode == AES_DECRYPT )
-    {
-        for( i = (ctx->nr >> 1) - 1; i > 0; i-- )
-        {
-            AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
-            AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
-        }
-
-        AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
-
-        X0 = *RK++ ^ \
-                ( (uint32_t) RSb[ ( Y0       ) & 0xFF ]       ) ^
-                ( (uint32_t) RSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
-
-        X1 = *RK++ ^ \
-                ( (uint32_t) RSb[ ( Y1       ) & 0xFF ]       ) ^
-                ( (uint32_t) RSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
-
-        X2 = *RK++ ^ \
-                ( (uint32_t) RSb[ ( Y2       ) & 0xFF ]       ) ^
-                ( (uint32_t) RSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
-
-        X3 = *RK++ ^ \
-                ( (uint32_t) RSb[ ( Y3       ) & 0xFF ]       ) ^
-                ( (uint32_t) RSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
-    }
-    else /* AES_ENCRYPT */
-    {
-        for( i = (ctx->nr >> 1) - 1; i > 0; i-- )
-        {
-            AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
-            AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
-        }
-
-        AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
-
-        X0 = *RK++ ^ \
-                ( (uint32_t) FSb[ ( Y0       ) & 0xFF ]       ) ^
-                ( (uint32_t) FSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
-
-        X1 = *RK++ ^ \
-                ( (uint32_t) FSb[ ( Y1       ) & 0xFF ]       ) ^
-                ( (uint32_t) FSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
-
-        X2 = *RK++ ^ \
-                ( (uint32_t) FSb[ ( Y2       ) & 0xFF ]       ) ^
-                ( (uint32_t) FSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
-
-        X3 = *RK++ ^ \
-                ( (uint32_t) FSb[ ( Y3       ) & 0xFF ]       ) ^
-                ( (uint32_t) FSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^
-                ( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
-                ( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
-    }
-
-    PUT_UINT32_LE( X0, output,  0 );
-    PUT_UINT32_LE( X1, output,  4 );
-    PUT_UINT32_LE( X2, output,  8 );
-    PUT_UINT32_LE( X3, output, 12 );
-
-    return( 0 );
-}
-
-/*
- * AES-CBC buffer encryption/decryption
- */
-int aes_crypt_cbc( aes_context *ctx,
-                    int mode,
-                    size_t length,
-                    unsigned char iv[16],
-                    const unsigned char *input,
-                    unsigned char *output )
-{
-    int i;
-    unsigned char temp[16];
-
-    if( length % 16 )
-        return( POLARSSL_ERR_AES_INVALID_INPUT_LENGTH );
-
-    if( mode == AES_DECRYPT )
-    {
-        while( length > 0 )
-        {
-            memcpy( temp, input, 16 );
-            aes_crypt_ecb( ctx, mode, input, output );
-
-            for( i = 0; i < 16; i++ )
-                output[i] = (unsigned char)( output[i] ^ iv[i] );
-
-            memcpy( iv, temp, 16 );
-
-            input  += 16;
-            output += 16;
-            length -= 16;
-        }
-    }
-    else
-    {
-        while( length > 0 )
-        {
-            for( i = 0; i < 16; i++ )
-                output[i] = (unsigned char)( input[i] ^ iv[i] );
-
-            aes_crypt_ecb( ctx, mode, output, output );
-            memcpy( iv, output, 16 );
-
-            input  += 16;
-            output += 16;
-            length -= 16;
-        }
-    }
-
-    return( 0 );
-}
-
-/*
- * AES-CFB128 buffer encryption/decryption
- */
-int aes_crypt_cfb128( aes_context *ctx,
-                       int mode,
-                       size_t length,
-                       size_t *iv_off,
-                       unsigned char iv[16],
-                       const unsigned char *input,
-                       unsigned char *output )
-{
-    int c;
-    size_t n = *iv_off;
-
-    if( mode == AES_DECRYPT )
-    {
-        while( length-- )
-        {
-            if( n == 0 )
-                aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
-
-            c = *input++;
-            *output++ = (unsigned char)( c ^ iv[n] );
-            iv[n] = (unsigned char) c;
-
-            n = (n + 1) & 0x0F;
-        }
-    }
-    else
-    {
-        while( length-- )
-        {
-            if( n == 0 )
-                aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
-
-            iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
-
-            n = (n + 1) & 0x0F;
-        }
-    }
-
-    *iv_off = n;
-
-    return( 0 );
-}
-
-/*
- * AES-CTR buffer encryption/decryption
- */
-int aes_crypt_ctr( aes_context *ctx,
-                       size_t length,
-                       size_t *nc_off,
-                       unsigned char nonce_counter[16],
-                       unsigned char stream_block[16],
-                       const unsigned char *input,
-                       unsigned char *output )
-{
-    int c, i;
-    size_t n = *nc_off;
-
-    while( length-- )
-    {
-        if( n == 0 ) {
-            aes_crypt_ecb( ctx, AES_ENCRYPT, nonce_counter, stream_block );
-
-            for( i = 16; i > 0; i-- )
-                if( ++nonce_counter[i - 1] != 0 )
-                    break;
-        }
-        c = *input++;
-        *output++ = (unsigned char)( c ^ stream_block[n] );
-
-        n = (n + 1) & 0x0F;
-    }
-
-    *nc_off = n;
-
-    return( 0 );
-}
-
+/*
+ *  FIPS-197 compliant AES implementation
+ *
+ *  Copyright (C) 2006-2013, Brainspark B.V.
+ *
+ *  This file is part of PolarSSL (http://www.polarssl.org)
+ *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
+ *
+ *  All rights reserved.
+ *
+ *  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; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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 for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+/*
+ *  The AES block cipher was designed by Vincent Rijmen and Joan Daemen.
+ *
+ *  http://csrc.nist.gov/encryption/aes/rijndael/Rijndael.pdf
+ *  http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
+ */
+
+#include "stdafx.h"
+#include "aes.h"
+
+/*
+ * 32-bit integer manipulation macros (little endian)
+ */
+#ifndef GET_UINT32_LE
+#define GET_UINT32_LE(n,b,i)                            \
+{                                                       \
+    (n) = ( (uint32_t) (b)[(i)    ]       )             \
+        | ( (uint32_t) (b)[(i) + 1] <<  8 )             \
+        | ( (uint32_t) (b)[(i) + 2] << 16 )             \
+        | ( (uint32_t) (b)[(i) + 3] << 24 );            \
+}
+#endif
+
+#ifndef PUT_UINT32_LE
+#define PUT_UINT32_LE(n,b,i)                            \
+{                                                       \
+    (b)[(i)    ] = (unsigned char) ( (n)       );       \
+    (b)[(i) + 1] = (unsigned char) ( (n) >>  8 );       \
+    (b)[(i) + 2] = (unsigned char) ( (n) >> 16 );       \
+    (b)[(i) + 3] = (unsigned char) ( (n) >> 24 );       \
+}
+#endif
+
+#if defined(POLARSSL_AES_ROM_TABLES)
+/*
+ * Forward S-box
+ */
+static const unsigned char FSb[256] =
+{
+    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
+    0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
+    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
+    0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
+    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
+    0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
+    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
+    0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
+    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
+    0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
+    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
+    0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
+    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,
+    0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
+    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
+    0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
+    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
+    0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
+    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,
+    0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
+    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
+    0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
+    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,
+    0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
+    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
+    0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
+    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
+    0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
+    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,
+    0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
+    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,
+    0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
+};
+
+/*
+ * Forward tables
+ */
+#define FT \
+\
+    V(A5,63,63,C6), V(84,7C,7C,F8), V(99,77,77,EE), V(8D,7B,7B,F6), \
+    V(0D,F2,F2,FF), V(BD,6B,6B,D6), V(B1,6F,6F,DE), V(54,C5,C5,91), \
+    V(50,30,30,60), V(03,01,01,02), V(A9,67,67,CE), V(7D,2B,2B,56), \
+    V(19,FE,FE,E7), V(62,D7,D7,B5), V(E6,AB,AB,4D), V(9A,76,76,EC), \
+    V(45,CA,CA,8F), V(9D,82,82,1F), V(40,C9,C9,89), V(87,7D,7D,FA), \
+    V(15,FA,FA,EF), V(EB,59,59,B2), V(C9,47,47,8E), V(0B,F0,F0,FB), \
+    V(EC,AD,AD,41), V(67,D4,D4,B3), V(FD,A2,A2,5F), V(EA,AF,AF,45), \
+    V(BF,9C,9C,23), V(F7,A4,A4,53), V(96,72,72,E4), V(5B,C0,C0,9B), \
+    V(C2,B7,B7,75), V(1C,FD,FD,E1), V(AE,93,93,3D), V(6A,26,26,4C), \
+    V(5A,36,36,6C), V(41,3F,3F,7E), V(02,F7,F7,F5), V(4F,CC,CC,83), \
+    V(5C,34,34,68), V(F4,A5,A5,51), V(34,E5,E5,D1), V(08,F1,F1,F9), \
+    V(93,71,71,E2), V(73,D8,D8,AB), V(53,31,31,62), V(3F,15,15,2A), \
+    V(0C,04,04,08), V(52,C7,C7,95), V(65,23,23,46), V(5E,C3,C3,9D), \
+    V(28,18,18,30), V(A1,96,96,37), V(0F,05,05,0A), V(B5,9A,9A,2F), \
+    V(09,07,07,0E), V(36,12,12,24), V(9B,80,80,1B), V(3D,E2,E2,DF), \
+    V(26,EB,EB,CD), V(69,27,27,4E), V(CD,B2,B2,7F), V(9F,75,75,EA), \
+    V(1B,09,09,12), V(9E,83,83,1D), V(74,2C,2C,58), V(2E,1A,1A,34), \
+    V(2D,1B,1B,36), V(B2,6E,6E,DC), V(EE,5A,5A,B4), V(FB,A0,A0,5B), \
+    V(F6,52,52,A4), V(4D,3B,3B,76), V(61,D6,D6,B7), V(CE,B3,B3,7D), \
+    V(7B,29,29,52), V(3E,E3,E3,DD), V(71,2F,2F,5E), V(97,84,84,13), \
+    V(F5,53,53,A6), V(68,D1,D1,B9), V(00,00,00,00), V(2C,ED,ED,C1), \
+    V(60,20,20,40), V(1F,FC,FC,E3), V(C8,B1,B1,79), V(ED,5B,5B,B6), \
+    V(BE,6A,6A,D4), V(46,CB,CB,8D), V(D9,BE,BE,67), V(4B,39,39,72), \
+    V(DE,4A,4A,94), V(D4,4C,4C,98), V(E8,58,58,B0), V(4A,CF,CF,85), \
+    V(6B,D0,D0,BB), V(2A,EF,EF,C5), V(E5,AA,AA,4F), V(16,FB,FB,ED), \
+    V(C5,43,43,86), V(D7,4D,4D,9A), V(55,33,33,66), V(94,85,85,11), \
+    V(CF,45,45,8A), V(10,F9,F9,E9), V(06,02,02,04), V(81,7F,7F,FE), \
+    V(F0,50,50,A0), V(44,3C,3C,78), V(BA,9F,9F,25), V(E3,A8,A8,4B), \
+    V(F3,51,51,A2), V(FE,A3,A3,5D), V(C0,40,40,80), V(8A,8F,8F,05), \
+    V(AD,92,92,3F), V(BC,9D,9D,21), V(48,38,38,70), V(04,F5,F5,F1), \
+    V(DF,BC,BC,63), V(C1,B6,B6,77), V(75,DA,DA,AF), V(63,21,21,42), \
+    V(30,10,10,20), V(1A,FF,FF,E5), V(0E,F3,F3,FD), V(6D,D2,D2,BF), \
+    V(4C,CD,CD,81), V(14,0C,0C,18), V(35,13,13,26), V(2F,EC,EC,C3), \
+    V(E1,5F,5F,BE), V(A2,97,97,35), V(CC,44,44,88), V(39,17,17,2E), \
+    V(57,C4,C4,93), V(F2,A7,A7,55), V(82,7E,7E,FC), V(47,3D,3D,7A), \
+    V(AC,64,64,C8), V(E7,5D,5D,BA), V(2B,19,19,32), V(95,73,73,E6), \
+    V(A0,60,60,C0), V(98,81,81,19), V(D1,4F,4F,9E), V(7F,DC,DC,A3), \
+    V(66,22,22,44), V(7E,2A,2A,54), V(AB,90,90,3B), V(83,88,88,0B), \
+    V(CA,46,46,8C), V(29,EE,EE,C7), V(D3,B8,B8,6B), V(3C,14,14,28), \
+    V(79,DE,DE,A7), V(E2,5E,5E,BC), V(1D,0B,0B,16), V(76,DB,DB,AD), \
+    V(3B,E0,E0,DB), V(56,32,32,64), V(4E,3A,3A,74), V(1E,0A,0A,14), \
+    V(DB,49,49,92), V(0A,06,06,0C), V(6C,24,24,48), V(E4,5C,5C,B8), \
+    V(5D,C2,C2,9F), V(6E,D3,D3,BD), V(EF,AC,AC,43), V(A6,62,62,C4), \
+    V(A8,91,91,39), V(A4,95,95,31), V(37,E4,E4,D3), V(8B,79,79,F2), \
+    V(32,E7,E7,D5), V(43,C8,C8,8B), V(59,37,37,6E), V(B7,6D,6D,DA), \
+    V(8C,8D,8D,01), V(64,D5,D5,B1), V(D2,4E,4E,9C), V(E0,A9,A9,49), \
+    V(B4,6C,6C,D8), V(FA,56,56,AC), V(07,F4,F4,F3), V(25,EA,EA,CF), \
+    V(AF,65,65,CA), V(8E,7A,7A,F4), V(E9,AE,AE,47), V(18,08,08,10), \
+    V(D5,BA,BA,6F), V(88,78,78,F0), V(6F,25,25,4A), V(72,2E,2E,5C), \
+    V(24,1C,1C,38), V(F1,A6,A6,57), V(C7,B4,B4,73), V(51,C6,C6,97), \
+    V(23,E8,E8,CB), V(7C,DD,DD,A1), V(9C,74,74,E8), V(21,1F,1F,3E), \
+    V(DD,4B,4B,96), V(DC,BD,BD,61), V(86,8B,8B,0D), V(85,8A,8A,0F), \
+    V(90,70,70,E0), V(42,3E,3E,7C), V(C4,B5,B5,71), V(AA,66,66,CC), \
+    V(D8,48,48,90), V(05,03,03,06), V(01,F6,F6,F7), V(12,0E,0E,1C), \
+    V(A3,61,61,C2), V(5F,35,35,6A), V(F9,57,57,AE), V(D0,B9,B9,69), \
+    V(91,86,86,17), V(58,C1,C1,99), V(27,1D,1D,3A), V(B9,9E,9E,27), \
+    V(38,E1,E1,D9), V(13,F8,F8,EB), V(B3,98,98,2B), V(33,11,11,22), \
+    V(BB,69,69,D2), V(70,D9,D9,A9), V(89,8E,8E,07), V(A7,94,94,33), \
+    V(B6,9B,9B,2D), V(22,1E,1E,3C), V(92,87,87,15), V(20,E9,E9,C9), \
+    V(49,CE,CE,87), V(FF,55,55,AA), V(78,28,28,50), V(7A,DF,DF,A5), \
+    V(8F,8C,8C,03), V(F8,A1,A1,59), V(80,89,89,09), V(17,0D,0D,1A), \
+    V(DA,BF,BF,65), V(31,E6,E6,D7), V(C6,42,42,84), V(B8,68,68,D0), \
+    V(C3,41,41,82), V(B0,99,99,29), V(77,2D,2D,5A), V(11,0F,0F,1E), \
+    V(CB,B0,B0,7B), V(FC,54,54,A8), V(D6,BB,BB,6D), V(3A,16,16,2C)
+
+#define V(a,b,c,d) 0x##a##b##c##d
+static const uint32_t FT0[256] = { FT };
+#undef V
+
+#define V(a,b,c,d) 0x##b##c##d##a
+static const uint32_t FT1[256] = { FT };
+#undef V
+
+#define V(a,b,c,d) 0x##c##d##a##b
+static const uint32_t FT2[256] = { FT };
+#undef V
+
+#define V(a,b,c,d) 0x##d##a##b##c
+static const uint32_t FT3[256] = { FT };
+#undef V
+
+#undef FT
+
+/*
+ * Reverse S-box
+ */
+static const unsigned char RSb[256] =
+{
+    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
+    0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
+    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
+    0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
+    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,
+    0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
+    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,
+    0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
+    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
+    0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
+    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
+    0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
+    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,
+    0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
+    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
+    0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
+    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,
+    0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
+    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,
+    0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
+    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
+    0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
+    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,
+    0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
+    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,
+    0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
+    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
+    0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
+    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,
+    0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
+    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,
+    0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
+};
+
+/*
+ * Reverse tables
+ */
+#define RT \
+\
+    V(50,A7,F4,51), V(53,65,41,7E), V(C3,A4,17,1A), V(96,5E,27,3A), \
+    V(CB,6B,AB,3B), V(F1,45,9D,1F), V(AB,58,FA,AC), V(93,03,E3,4B), \
+    V(55,FA,30,20), V(F6,6D,76,AD), V(91,76,CC,88), V(25,4C,02,F5), \
+    V(FC,D7,E5,4F), V(D7,CB,2A,C5), V(80,44,35,26), V(8F,A3,62,B5), \
+    V(49,5A,B1,DE), V(67,1B,BA,25), V(98,0E,EA,45), V(E1,C0,FE,5D), \
+    V(02,75,2F,C3), V(12,F0,4C,81), V(A3,97,46,8D), V(C6,F9,D3,6B), \
+    V(E7,5F,8F,03), V(95,9C,92,15), V(EB,7A,6D,BF), V(DA,59,52,95), \
+    V(2D,83,BE,D4), V(D3,21,74,58), V(29,69,E0,49), V(44,C8,C9,8E), \
+    V(6A,89,C2,75), V(78,79,8E,F4), V(6B,3E,58,99), V(DD,71,B9,27), \
+    V(B6,4F,E1,BE), V(17,AD,88,F0), V(66,AC,20,C9), V(B4,3A,CE,7D), \
+    V(18,4A,DF,63), V(82,31,1A,E5), V(60,33,51,97), V(45,7F,53,62), \
+    V(E0,77,64,B1), V(84,AE,6B,BB), V(1C,A0,81,FE), V(94,2B,08,F9), \
+    V(58,68,48,70), V(19,FD,45,8F), V(87,6C,DE,94), V(B7,F8,7B,52), \
+    V(23,D3,73,AB), V(E2,02,4B,72), V(57,8F,1F,E3), V(2A,AB,55,66), \
+    V(07,28,EB,B2), V(03,C2,B5,2F), V(9A,7B,C5,86), V(A5,08,37,D3), \
+    V(F2,87,28,30), V(B2,A5,BF,23), V(BA,6A,03,02), V(5C,82,16,ED), \
+    V(2B,1C,CF,8A), V(92,B4,79,A7), V(F0,F2,07,F3), V(A1,E2,69,4E), \
+    V(CD,F4,DA,65), V(D5,BE,05,06), V(1F,62,34,D1), V(8A,FE,A6,C4), \
+    V(9D,53,2E,34), V(A0,55,F3,A2), V(32,E1,8A,05), V(75,EB,F6,A4), \
+    V(39,EC,83,0B), V(AA,EF,60,40), V(06,9F,71,5E), V(51,10,6E,BD), \
+    V(F9,8A,21,3E), V(3D,06,DD,96), V(AE,05,3E,DD), V(46,BD,E6,4D), \
+    V(B5,8D,54,91), V(05,5D,C4,71), V(6F,D4,06,04), V(FF,15,50,60), \
+    V(24,FB,98,19), V(97,E9,BD,D6), V(CC,43,40,89), V(77,9E,D9,67), \
+    V(BD,42,E8,B0), V(88,8B,89,07), V(38,5B,19,E7), V(DB,EE,C8,79), \
+    V(47,0A,7C,A1), V(E9,0F,42,7C), V(C9,1E,84,F8), V(00,00,00,00), \
+    V(83,86,80,09), V(48,ED,2B,32), V(AC,70,11,1E), V(4E,72,5A,6C), \
+    V(FB,FF,0E,FD), V(56,38,85,0F), V(1E,D5,AE,3D), V(27,39,2D,36), \
+    V(64,D9,0F,0A), V(21,A6,5C,68), V(D1,54,5B,9B), V(3A,2E,36,24), \
+    V(B1,67,0A,0C), V(0F,E7,57,93), V(D2,96,EE,B4), V(9E,91,9B,1B), \
+    V(4F,C5,C0,80), V(A2,20,DC,61), V(69,4B,77,5A), V(16,1A,12,1C), \
+    V(0A,BA,93,E2), V(E5,2A,A0,C0), V(43,E0,22,3C), V(1D,17,1B,12), \
+    V(0B,0D,09,0E), V(AD,C7,8B,F2), V(B9,A8,B6,2D), V(C8,A9,1E,14), \
+    V(85,19,F1,57), V(4C,07,75,AF), V(BB,DD,99,EE), V(FD,60,7F,A3), \
+    V(9F,26,01,F7), V(BC,F5,72,5C), V(C5,3B,66,44), V(34,7E,FB,5B), \
+    V(76,29,43,8B), V(DC,C6,23,CB), V(68,FC,ED,B6), V(63,F1,E4,B8), \
+    V(CA,DC,31,D7), V(10,85,63,42), V(40,22,97,13), V(20,11,C6,84), \
+    V(7D,24,4A,85), V(F8,3D,BB,D2), V(11,32,F9,AE), V(6D,A1,29,C7), \
+    V(4B,2F,9E,1D), V(F3,30,B2,DC), V(EC,52,86,0D), V(D0,E3,C1,77), \
+    V(6C,16,B3,2B), V(99,B9,70,A9), V(FA,48,94,11), V(22,64,E9,47), \
+    V(C4,8C,FC,A8), V(1A,3F,F0,A0), V(D8,2C,7D,56), V(EF,90,33,22), \
+    V(C7,4E,49,87), V(C1,D1,38,D9), V(FE,A2,CA,8C), V(36,0B,D4,98), \
+    V(CF,81,F5,A6), V(28,DE,7A,A5), V(26,8E,B7,DA), V(A4,BF,AD,3F), \
+    V(E4,9D,3A,2C), V(0D,92,78,50), V(9B,CC,5F,6A), V(62,46,7E,54), \
+    V(C2,13,8D,F6), V(E8,B8,D8,90), V(5E,F7,39,2E), V(F5,AF,C3,82), \
+    V(BE,80,5D,9F), V(7C,93,D0,69), V(A9,2D,D5,6F), V(B3,12,25,CF), \
+    V(3B,99,AC,C8), V(A7,7D,18,10), V(6E,63,9C,E8), V(7B,BB,3B,DB), \
+    V(09,78,26,CD), V(F4,18,59,6E), V(01,B7,9A,EC), V(A8,9A,4F,83), \
+    V(65,6E,95,E6), V(7E,E6,FF,AA), V(08,CF,BC,21), V(E6,E8,15,EF), \
+    V(D9,9B,E7,BA), V(CE,36,6F,4A), V(D4,09,9F,EA), V(D6,7C,B0,29), \
+    V(AF,B2,A4,31), V(31,23,3F,2A), V(30,94,A5,C6), V(C0,66,A2,35), \
+    V(37,BC,4E,74), V(A6,CA,82,FC), V(B0,D0,90,E0), V(15,D8,A7,33), \
+    V(4A,98,04,F1), V(F7,DA,EC,41), V(0E,50,CD,7F), V(2F,F6,91,17), \
+    V(8D,D6,4D,76), V(4D,B0,EF,43), V(54,4D,AA,CC), V(DF,04,96,E4), \
+    V(E3,B5,D1,9E), V(1B,88,6A,4C), V(B8,1F,2C,C1), V(7F,51,65,46), \
+    V(04,EA,5E,9D), V(5D,35,8C,01), V(73,74,87,FA), V(2E,41,0B,FB), \
+    V(5A,1D,67,B3), V(52,D2,DB,92), V(33,56,10,E9), V(13,47,D6,6D), \
+    V(8C,61,D7,9A), V(7A,0C,A1,37), V(8E,14,F8,59), V(89,3C,13,EB), \
+    V(EE,27,A9,CE), V(35,C9,61,B7), V(ED,E5,1C,E1), V(3C,B1,47,7A), \
+    V(59,DF,D2,9C), V(3F,73,F2,55), V(79,CE,14,18), V(BF,37,C7,73), \
+    V(EA,CD,F7,53), V(5B,AA,FD,5F), V(14,6F,3D,DF), V(86,DB,44,78), \
+    V(81,F3,AF,CA), V(3E,C4,68,B9), V(2C,34,24,38), V(5F,40,A3,C2), \
+    V(72,C3,1D,16), V(0C,25,E2,BC), V(8B,49,3C,28), V(41,95,0D,FF), \
+    V(71,01,A8,39), V(DE,B3,0C,08), V(9C,E4,B4,D8), V(90,C1,56,64), \
+    V(61,84,CB,7B), V(70,B6,32,D5), V(74,5C,6C,48), V(42,57,B8,D0)
+
+#define V(a,b,c,d) 0x##a##b##c##d
+static const uint32_t RT0[256] = { RT };
+#undef V
+
+#define V(a,b,c,d) 0x##b##c##d##a
+static const uint32_t RT1[256] = { RT };
+#undef V
+
+#define V(a,b,c,d) 0x##c##d##a##b
+static const uint32_t RT2[256] = { RT };
+#undef V
+
+#define V(a,b,c,d) 0x##d##a##b##c
+static const uint32_t RT3[256] = { RT };
+#undef V
+
+#undef RT
+
+/*
+ * Round constants
+ */
+static const uint32_t RCON[10] =
+{
+    0x00000001, 0x00000002, 0x00000004, 0x00000008,
+    0x00000010, 0x00000020, 0x00000040, 0x00000080,
+    0x0000001B, 0x00000036
+};
+
+#else
+
+/*
+ * Forward S-box & tables
+ */
+static unsigned char FSb[256];
+static uint32_t FT0[256]; 
+static uint32_t FT1[256]; 
+static uint32_t FT2[256]; 
+static uint32_t FT3[256]; 
+
+/*
+ * Reverse S-box & tables
+ */
+static unsigned char RSb[256];
+static uint32_t RT0[256];
+static uint32_t RT1[256];
+static uint32_t RT2[256];
+static uint32_t RT3[256];
+
+/*
+ * Round constants
+ */
+static uint32_t RCON[10];
+
+/*
+ * Tables generation code
+ */
+#define ROTL8(x) ( ( x << 8 ) & 0xFFFFFFFF ) | ( x >> 24 )
+#define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )
+#define MUL(x,y) ( ( x && y ) ? pow[(log[x]+log[y]) % 255] : 0 )
+
+static int aes_init_done = 0;
+
+static void aes_gen_tables( void )
+{
+    int i, x, y, z;
+    int pow[256];
+    int log[256];
+
+    /*
+     * compute pow and log tables over GF(2^8)
+     */
+    for( i = 0, x = 1; i < 256; i++ )
+    {
+        pow[i] = x;
+        log[x] = i;
+        x = ( x ^ XTIME( x ) ) & 0xFF;
+    }
+
+    /*
+     * calculate the round constants
+     */
+    for( i = 0, x = 1; i < 10; i++ )
+    {
+        RCON[i] = (uint32_t) x;
+        x = XTIME( x ) & 0xFF;
+    }
+
+    /*
+     * generate the forward and reverse S-boxes
+     */
+    FSb[0x00] = 0x63;
+    RSb[0x63] = 0x00;
+
+    for( i = 1; i < 256; i++ )
+    {
+        x = pow[255 - log[i]];
+
+        y  = x; y = ( (y << 1) | (y >> 7) ) & 0xFF;
+        x ^= y; y = ( (y << 1) | (y >> 7) ) & 0xFF;
+        x ^= y; y = ( (y << 1) | (y >> 7) ) & 0xFF;
+        x ^= y; y = ( (y << 1) | (y >> 7) ) & 0xFF;
+        x ^= y ^ 0x63;
+
+        FSb[i] = (unsigned char) x;
+        RSb[x] = (unsigned char) i;
+    }
+
+    /*
+     * generate the forward and reverse tables
+     */
+    for( i = 0; i < 256; i++ )
+    {
+        x = FSb[i];
+        y = XTIME( x ) & 0xFF;
+        z =  ( y ^ x ) & 0xFF;
+
+        FT0[i] = ( (uint32_t) y       ) ^
+                 ( (uint32_t) x <<  8 ) ^
+                 ( (uint32_t) x << 16 ) ^
+                 ( (uint32_t) z << 24 );
+
+        FT1[i] = ROTL8( FT0[i] );
+        FT2[i] = ROTL8( FT1[i] );
+        FT3[i] = ROTL8( FT2[i] );
+
+        x = RSb[i];
+
+        RT0[i] = ( (uint32_t) MUL( 0x0E, x )       ) ^
+                 ( (uint32_t) MUL( 0x09, x ) <<  8 ) ^
+                 ( (uint32_t) MUL( 0x0D, x ) << 16 ) ^
+                 ( (uint32_t) MUL( 0x0B, x ) << 24 );
+
+        RT1[i] = ROTL8( RT0[i] );
+        RT2[i] = ROTL8( RT1[i] );
+        RT3[i] = ROTL8( RT2[i] );
+    }
+}
+
+#endif
+
+/*
+ * AES key schedule (encryption)
+ */
+int aes_setkey_enc( aes_context *ctx, const unsigned char *key, unsigned int keysize )
+{
+    unsigned int i;
+    uint32_t *RK;
+
+#if !defined(POLARSSL_AES_ROM_TABLES)
+    if( aes_init_done == 0 )
+    {
+        aes_gen_tables();
+        aes_init_done = 1;
+
+    }
+#endif
+
+    switch( keysize )
+    {
+        case 128: ctx->nr = 10; break;
+        case 192: ctx->nr = 12; break;
+        case 256: ctx->nr = 14; break;
+        default : return( POLARSSL_ERR_AES_INVALID_KEY_LENGTH );
+    }
+
+    ctx->rk = RK = ctx->buf;
+
+    for( i = 0; i < (keysize >> 5); i++ )
+    {
+        GET_UINT32_LE( RK[i], key, i << 2 );
+    }
+
+    switch( ctx->nr )
+    {
+        case 10:
+
+            for( i = 0; i < 10; i++, RK += 4 )
+            {
+                RK[4]  = RK[0] ^ RCON[i] ^
+                ( (uint32_t) FSb[ ( RK[3] >>  8 ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( RK[3]       ) & 0xFF ] << 24 );
+
+                RK[5]  = RK[1] ^ RK[4];
+                RK[6]  = RK[2] ^ RK[5];
+                RK[7]  = RK[3] ^ RK[6];
+            }
+            break;
+
+        case 12:
+
+            for( i = 0; i < 8; i++, RK += 6 )
+            {
+                RK[6]  = RK[0] ^ RCON[i] ^
+                ( (uint32_t) FSb[ ( RK[5] >>  8 ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( RK[5]       ) & 0xFF ] << 24 );
+
+                RK[7]  = RK[1] ^ RK[6];
+                RK[8]  = RK[2] ^ RK[7];
+                RK[9]  = RK[3] ^ RK[8];
+                RK[10] = RK[4] ^ RK[9];
+                RK[11] = RK[5] ^ RK[10];
+            }
+            break;
+
+        case 14:
+
+            for( i = 0; i < 7; i++, RK += 8 )
+            {
+                RK[8]  = RK[0] ^ RCON[i] ^
+                ( (uint32_t) FSb[ ( RK[7] >>  8 ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( RK[7]       ) & 0xFF ] << 24 );
+
+                RK[9]  = RK[1] ^ RK[8];
+                RK[10] = RK[2] ^ RK[9];
+                RK[11] = RK[3] ^ RK[10];
+
+                RK[12] = RK[4] ^
+                ( (uint32_t) FSb[ ( RK[11]       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( RK[11] >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
+
+                RK[13] = RK[5] ^ RK[12];
+                RK[14] = RK[6] ^ RK[13];
+                RK[15] = RK[7] ^ RK[14];
+            }
+            break;
+
+        default:
+
+            break;
+    }
+
+    return( 0 );
+}
+
+/*
+ * AES key schedule (decryption)
+ */
+int aes_setkey_dec( aes_context *ctx, const unsigned char *key, unsigned int keysize )
+{
+    int i, j;
+    aes_context cty;
+    uint32_t *RK;
+    uint32_t *SK;
+    int ret;
+
+    switch( keysize )
+    {
+        case 128: ctx->nr = 10; break;
+        case 192: ctx->nr = 12; break;
+        case 256: ctx->nr = 14; break;
+        default : return( POLARSSL_ERR_AES_INVALID_KEY_LENGTH );
+    }
+
+    ctx->rk = RK = ctx->buf;
+
+    ret = aes_setkey_enc( &cty, key, keysize );
+    if( ret != 0 )
+        return( ret );
+
+    SK = cty.rk + cty.nr * 4;
+
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+
+    for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
+    {
+        for( j = 0; j < 4; j++, SK++ )
+        {
+            *RK++ = RT0[ FSb[ ( *SK       ) & 0xFF ] ] ^
+                    RT1[ FSb[ ( *SK >>  8 ) & 0xFF ] ] ^
+                    RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
+                    RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ];
+        }
+    }
+
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+
+    memset( &cty, 0, sizeof( aes_context ) );
+
+    return( 0 );
+}
+
+#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
+{                                               \
+    X0 = *RK++ ^ FT0[ ( Y0       ) & 0xFF ] ^   \
+                 FT1[ ( Y1 >>  8 ) & 0xFF ] ^   \
+                 FT2[ ( Y2 >> 16 ) & 0xFF ] ^   \
+                 FT3[ ( Y3 >> 24 ) & 0xFF ];    \
+                                                \
+    X1 = *RK++ ^ FT0[ ( Y1       ) & 0xFF ] ^   \
+                 FT1[ ( Y2 >>  8 ) & 0xFF ] ^   \
+                 FT2[ ( Y3 >> 16 ) & 0xFF ] ^   \
+                 FT3[ ( Y0 >> 24 ) & 0xFF ];    \
+                                                \
+    X2 = *RK++ ^ FT0[ ( Y2       ) & 0xFF ] ^   \
+                 FT1[ ( Y3 >>  8 ) & 0xFF ] ^   \
+                 FT2[ ( Y0 >> 16 ) & 0xFF ] ^   \
+                 FT3[ ( Y1 >> 24 ) & 0xFF ];    \
+                                                \
+    X3 = *RK++ ^ FT0[ ( Y3       ) & 0xFF ] ^   \
+                 FT1[ ( Y0 >>  8 ) & 0xFF ] ^   \
+                 FT2[ ( Y1 >> 16 ) & 0xFF ] ^   \
+                 FT3[ ( Y2 >> 24 ) & 0xFF ];    \
+}
+
+#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
+{                                               \
+    X0 = *RK++ ^ RT0[ ( Y0       ) & 0xFF ] ^   \
+                 RT1[ ( Y3 >>  8 ) & 0xFF ] ^   \
+                 RT2[ ( Y2 >> 16 ) & 0xFF ] ^   \
+                 RT3[ ( Y1 >> 24 ) & 0xFF ];    \
+                                                \
+    X1 = *RK++ ^ RT0[ ( Y1       ) & 0xFF ] ^   \
+                 RT1[ ( Y0 >>  8 ) & 0xFF ] ^   \
+                 RT2[ ( Y3 >> 16 ) & 0xFF ] ^   \
+                 RT3[ ( Y2 >> 24 ) & 0xFF ];    \
+                                                \
+    X2 = *RK++ ^ RT0[ ( Y2       ) & 0xFF ] ^   \
+                 RT1[ ( Y1 >>  8 ) & 0xFF ] ^   \
+                 RT2[ ( Y0 >> 16 ) & 0xFF ] ^   \
+                 RT3[ ( Y3 >> 24 ) & 0xFF ];    \
+                                                \
+    X3 = *RK++ ^ RT0[ ( Y3       ) & 0xFF ] ^   \
+                 RT1[ ( Y2 >>  8 ) & 0xFF ] ^   \
+                 RT2[ ( Y1 >> 16 ) & 0xFF ] ^   \
+                 RT3[ ( Y0 >> 24 ) & 0xFF ];    \
+}
+
+/*
+ * AES-ECB block encryption/decryption
+ */
+int aes_crypt_ecb( aes_context *ctx,
+                    int mode,
+                    const unsigned char input[16],
+                    unsigned char output[16] )
+{
+    int i;
+    uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
+
+    RK = ctx->rk;
+
+    GET_UINT32_LE( X0, input,  0 ); X0 ^= *RK++;
+    GET_UINT32_LE( X1, input,  4 ); X1 ^= *RK++;
+    GET_UINT32_LE( X2, input,  8 ); X2 ^= *RK++;
+    GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
+
+    if( mode == AES_DECRYPT )
+    {
+        for( i = (ctx->nr >> 1) - 1; i > 0; i-- )
+        {
+            AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
+            AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
+        }
+
+        AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
+
+        X0 = *RK++ ^ \
+                ( (uint32_t) RSb[ ( Y0       ) & 0xFF ]       ) ^
+                ( (uint32_t) RSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
+
+        X1 = *RK++ ^ \
+                ( (uint32_t) RSb[ ( Y1       ) & 0xFF ]       ) ^
+                ( (uint32_t) RSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
+
+        X2 = *RK++ ^ \
+                ( (uint32_t) RSb[ ( Y2       ) & 0xFF ]       ) ^
+                ( (uint32_t) RSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
+
+        X3 = *RK++ ^ \
+                ( (uint32_t) RSb[ ( Y3       ) & 0xFF ]       ) ^
+                ( (uint32_t) RSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
+    }
+    else /* AES_ENCRYPT */
+    {
+        for( i = (ctx->nr >> 1) - 1; i > 0; i-- )
+        {
+            AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
+            AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
+        }
+
+        AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
+
+        X0 = *RK++ ^ \
+                ( (uint32_t) FSb[ ( Y0       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
+
+        X1 = *RK++ ^ \
+                ( (uint32_t) FSb[ ( Y1       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
+
+        X2 = *RK++ ^ \
+                ( (uint32_t) FSb[ ( Y2       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
+
+        X3 = *RK++ ^ \
+                ( (uint32_t) FSb[ ( Y3       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
+    }
+
+    PUT_UINT32_LE( X0, output,  0 );
+    PUT_UINT32_LE( X1, output,  4 );
+    PUT_UINT32_LE( X2, output,  8 );
+    PUT_UINT32_LE( X3, output, 12 );
+
+    return( 0 );
+}
+
+/*
+ * AES-CBC buffer encryption/decryption
+ */
+int aes_crypt_cbc( aes_context *ctx,
+                    int mode,
+                    size_t length,
+                    unsigned char iv[16],
+                    const unsigned char *input,
+                    unsigned char *output )
+{
+    int i;
+    unsigned char temp[16];
+
+    if( length % 16 )
+        return( POLARSSL_ERR_AES_INVALID_INPUT_LENGTH );
+
+    if( mode == AES_DECRYPT )
+    {
+        while( length > 0 )
+        {
+            memcpy( temp, input, 16 );
+            aes_crypt_ecb( ctx, mode, input, output );
+
+            for( i = 0; i < 16; i++ )
+                output[i] = (unsigned char)( output[i] ^ iv[i] );
+
+            memcpy( iv, temp, 16 );
+
+            input  += 16;
+            output += 16;
+            length -= 16;
+        }
+    }
+    else
+    {
+        while( length > 0 )
+        {
+            for( i = 0; i < 16; i++ )
+                output[i] = (unsigned char)( input[i] ^ iv[i] );
+
+            aes_crypt_ecb( ctx, mode, output, output );
+            memcpy( iv, output, 16 );
+
+            input  += 16;
+            output += 16;
+            length -= 16;
+        }
+    }
+
+    return( 0 );
+}
+
+/*
+ * AES-CFB128 buffer encryption/decryption
+ */
+int aes_crypt_cfb128( aes_context *ctx,
+                       int mode,
+                       size_t length,
+                       size_t *iv_off,
+                       unsigned char iv[16],
+                       const unsigned char *input,
+                       unsigned char *output )
+{
+    int c;
+    size_t n = *iv_off;
+
+    if( mode == AES_DECRYPT )
+    {
+        while( length-- )
+        {
+            if( n == 0 )
+                aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+
+            c = *input++;
+            *output++ = (unsigned char)( c ^ iv[n] );
+            iv[n] = (unsigned char) c;
+
+            n = (n + 1) & 0x0F;
+        }
+    }
+    else
+    {
+        while( length-- )
+        {
+            if( n == 0 )
+                aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+
+            iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
+
+            n = (n + 1) & 0x0F;
+        }
+    }
+
+    *iv_off = n;
+
+    return( 0 );
+}
+
+/*
+ * AES-CTR buffer encryption/decryption
+ */
+int aes_crypt_ctr( aes_context *ctx,
+                       size_t length,
+                       size_t *nc_off,
+                       unsigned char nonce_counter[16],
+                       unsigned char stream_block[16],
+                       const unsigned char *input,
+                       unsigned char *output )
+{
+    int c, i;
+    size_t n = *nc_off;
+
+    while( length-- )
+    {
+        if( n == 0 ) {
+            aes_crypt_ecb( ctx, AES_ENCRYPT, nonce_counter, stream_block );
+
+            for( i = 16; i > 0; i-- )
+                if( ++nonce_counter[i - 1] != 0 )
+                    break;
+        }
+        c = *input++;
+        *output++ = (unsigned char)( c ^ stream_block[n] );
+
+        n = (n + 1) & 0x0F;
+    }
+
+    *nc_off = n;
+
+    return( 0 );
+}
+
 /* AES-CMAC */
 
 unsigned char const_Rb[16] = {
diff --git a/rpcs3/Crypto/key_vault.cpp b/rpcs3/Crypto/key_vault.cpp
index 4926a428db..8565addb4d 100644
--- a/rpcs3/Crypto/key_vault.cpp
+++ b/rpcs3/Crypto/key_vault.cpp
@@ -1,836 +1,747 @@
-#include "stdafx.h"
-#include "key_vault.h"
-
-KeyVault::KeyVault()
-{
-}
-
-void KeyVault::LoadSelfLV0Keys()
-{
-	sk_LV0_arr.Clear();	
-	sk_LV0_arr.Move(
-		new SELF_KEY(0x0000000000000000, 0x0000, KEY_LV0,
-		"CA7A24EC38BDB45B98CCD7D363EA2AF0C326E65081E0630CB9AB2D215865878A",
-		"F9205F46F6021697E670F13DFA726212",
-		"A8FD6DB24532D094EFA08CB41C9A72287D905C6B27B42BE4AB925AAF4AFFF34D41EEB54DD128700D",
-		"001AD976FCDE86F5B8FF3E63EF3A7F94E861975BA3",
-		0x33));
-}
-
-void KeyVault::LoadSelfLDRKeys()
-{
-	sk_LDR_arr.Clear();	
-	sk_LDR_arr.Move(
-		new SELF_KEY(0x0000000000000000, 0x0000, KEY_LDR,
-		"C0CEFE84C227F75BD07A7EB846509F93B238E770DACB9FF4A388F812482BE21B",
-		"47EE7454E4774CC9B8960C7B59F4C14D",
-		"C2D4AAF319355019AF99D44E2B58CA29252C89123D11D6218F40B138CAB29B7101F3AEB72A975019",
-		"00C5B2BFA1A413DD16F26D31C0F2ED4720DCFB0670",
-		0x20));
-}
-
-void KeyVault::LoadSelfLV1Keys()
-{
-	sk_LV1_arr.Clear();
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0003003000000000, 0x0000, KEY_LV1,
-		"B9F3F9E6107CFF2680A91E118C2403CF4A6F18F3C7EFD7D13D1AC4DB760BD222",
-		"B43661B9A79BAD9D8E2B046469CDA1E7",
-		"4C870BE86DDD996A92A3F7F404F33604244A1D02AB5B78BC9DAF030B78BE8867CF586171B7D45D20",
-		"002CC736C7AD06D264E9AB663EB1F35F5DC159248C",
-		0x33));
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0003004200000000, 0x0000, KEY_LV1,
-		"B880593856C8C6D2037585626A12977F50DCFCF3F132D2C89AA6E670EAFC1646",
-		"A79B05D4E37B8117A95E6E7C14FB640E",
-		"7454C7CCBFC2F66C142D78A730A3A6F973CC0FB75A46FCBB390790138910A0CAC78E5E21F4DA3375",
-		"00033A699FDD2DA6CDD6CCC03B2C6145F998706F74",
-		0x34));
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0003005000000000, 0x0000, KEY_LV1,
-		"1E8EEEA9E80A729F3FA52CF523B25941EA44B4155D94E5DADC5C5A77847620C7",
-		"E034D31A80316960024D1B3D3164FDC3",
-		"7E3A196f4A5879F3A7B091A2263F7C24E1716129B580566D308D9C2254B36AEE53DEF30EC85F8398",
-		"005815D17125D04C33790321DE29EB6241365100B5",
-		0x35));
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0003005500000000, 0x0000, KEY_LV1,
-		"53ABDF84BE08B0351B734F2B97D2BE1621BC6C889E4362E5C70F39D6C3ED9F23",
-		"44E652661AC7584DBE08ECB810FB5FC0",
-		"733198A7759BC07326755BC9773A8A17C8A7043C7BDAB83D88E230512E2EA3852D7DA4263A7E97F9",
-		"004312C65347ACBE95CC306442FEFD0AF4C2935EB3",
-		0x05));
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0003005600000000, 0x0000, KEY_LV1,
-		"48793EBDDA1AF65D737DA2FDA2DD104447A698F8A82CAAEE992831711BA94E83",
-		"15DCF3C67147A45D09DE7521EECA07A1",
-		"85A8868C320127F10B6598964C69221C086702021D31803520E21FDE4DBE827766BE41825CB7328C",
-		"",
-		0x07));
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0003006100000000, 0x0000, KEY_LV1,
-		"5FF17D836E2C4AD69476E2614F64BDD05B9115389A9A6D055B5B544B1C34E3D5",
-		"DF0F50EC3C4743C5B17839D7B49F24A4",
-		"1CDABE30833823F461CA534104115FFF60010B710631E435A7D915E82AE88EDE667264656CB7062E",
-		"",
-		0x05));
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0003006600000000, 0x0000, KEY_LV1,
-		"BD0621FA19383C3C72ECBC3B008F1CD55FFD7C3BB7510BF11AD0CF0FC2B70951",
-		"569AF3745E1E02E3E288273CDE244CD8",
-		"21E26F11C2D69478609DD1BD278CDFC940D90386455BA52FCD1FA7E27AC2AFA826C79A10193B625C",
-		"",
-		0x07));
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0003007400000000, 0x0000, KEY_LV1,
-		"41A6E0039041E9D8AAF4EF2F2A2971248EDBD96A3985611ED7B4CE73EE4804FE",
-		"C8C98D5A5CE23AF5607A352AECACB0DC",
-		"4389664390265F96C1A882374C0F856364E33DB09BE124A4666F9A12F0DD9C811EDD55BA21ED0667",
-		"",
-		0x12));
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0004001100000000, 0x0000, KEY_LV1,
-		"557EDF6C063F3272B0D44EEC12F418DA774815B5415597CC5F75C21E048BAD74",
-		"7144D7574937818517826227EF4AC0B4",
-		"085D38DBF9B757329EB862107929909D32FA1DAE60641BF4AC25319D7650597EE977F8E810FEEA96",
-		"",
-		0x13));
-	sk_LV1_arr.Move(
-		new SELF_KEY(0x0004005000000000, 0x0000, KEY_LV1,
-		"10CEA04973FCCC12EC19924510822D8D4C41F657FD3D7E73F415A8D687421BCD",
-		"ED8699562C6AC65204FA166257E7FCF4",
-		"9AF86FC869C159FBB62F7D9674EE257ABF12E5A96D5875B4AA73C13C2BC13E2A4079F98B9B935EE2",
-		"",
-		0x14));
-}
-
-void KeyVault::LoadSelfLV2Keys()
-{
-	sk_LV2_arr.Clear();
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0003003000000000, 0x0000, KEY_LV2,
-		"94303F69513572AB5AE17C8C2A1839D2C24C28F65389D3BBB11894CE23E0798F",
-		"9769BFD187B90990AE5FEA4E110B9CF5",
-		"AFAF5E96AF396CBB69071082C46A8F34A030E8EDB799E0A7BE00AA264DFF3AEBF7923920D559404D",
-		"0070ABF9361B02291829D479F56AB248203CD3EB46",
-		0x20));
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0003004200000000, 0x0000, KEY_LV2,
-		"575B0A6C4B4F2760A03FE4189EBAF4D947279FD982B14070349098B08FF92C10",
-		"411CB18F460CE50CAF2C426D8F0D93C8",
-		"3FEE313954CB3039C321A7E33B97FFDEC8988A8B55759161B04DBF4731284E4A8191E3F17D32B0EA",
-		"0073076441A08CD179E5FACE349B86DA58B5B7BA78",
-		0x21));
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0003005000000000, 0x0000, KEY_LV2,
-		"6DBD48D787C58803A8D724DA5ACF04FF8FCE91D7545D2322F2B7ABF57014AF68",
-		"603A36213708520ED5D745DEC1325BA5",
-		"5888CB83AC3CCA9610BC173C53141C0CA58B93719E744660CA8823D5EAEE8F9BF736997054E4B7E3",
-		"0009EBC3DE442FA5FBF6C4F3D4F9EAB07778A142BD",
-		0x22));
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0003005500000000, 0x0000, KEY_LV2,
-		"84015E90FA23139628A3C75CC09714E6427B527A82D18ABC3E91CD8D7DDAFF17",
-		"5B240444D645F2038118F97FD5A145D5",
-		"B266318245266B2D33641CD8A864066D077FAC60B7E27399099A70A683454B70F9888E7CC0C2BF72",
-		"009D4CBA2BFB1A8330D3E20E59D281D476D231C73A",
-		0x32));
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0003005600000000, 0x0000, KEY_LV2,
-		"EAE15444048EFDE7A831BFA9F5D96F047C9FCFF50723E292CF50F5417D81E359",
-		"9CA9282DC7FA9F315EF3156D970B7CD4",
-		"0D58938CB47598A6A672874F1768068F8B80D8D17014D2ABEBAC85E5B0993D9FB6F307DDC3DDA699",
-		"",
-		0x33));
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0003006100000000, 0x0000, KEY_LV2,
-		"88AD367EDEC2FEED3E2F99B1C685075C41BDEC90C84F526CAF588F89BBD1CBCC",
-		"8D18E8E525230E63DE10291C9DD615BF",
-		"86EED1D65E58890ABDA9ACA486A2BDDB9C0A529C2053FAE301F0F698EAF443DA0F60595A597A7027",
-		"",
-		0x32));
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0003006600000000, 0x0000, KEY_LV2,
-		"688D5FCAC6F4EA35AC6AC79B10506007286131EE038116DB8AA2C0B0340D9FB0",
-		"75E0239D18B0B669EAE650972F99726B",
-		"008E1C820AC567D1BFB8FE3CC6AD2E1845A1D1B19ED2E18B18CA34A8D28A83EC60C63859CDB3DACA",
-		"",
-		0x33));
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0003007400000000, 0x0000, KEY_LV2,
-		"E81C5B04C29FB079A4A2687A39D4EA97BFB49D80EF546CEB292979A5F77A6254",
-		"15058FA7F2CAD7C528B5F605F6444EB0",
-		"438D0E5C1E7AFB18234DB6867472FF5F52B750F30C379C7DD1EE0FD23E417B3EA819CC01BAC480ED",
-		"",
-		0x11));
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0004001100000000, 0x0000, KEY_LV2,
-		"A1E4B86ED02BF7F1372A2C73FE02BC738907EB37CE3BA605FE783C999FAFDB97",
-		"BBE7799B9A37CB272E386618FDFD4AEC",
-		"5B31A8E2A663EBD673196E2E1022E0D64988C4E1BBFE5E474415883A3BA0D9C562A2BE9C30E9B4A8",
-		"",
-		0x07));
-	sk_LV2_arr.Move(
-		new SELF_KEY(0x0004005000000000, 0x0000, KEY_LV2,
-		"0CAF212B6FA53C0DA7E2C575ADF61DBE68F34A33433B1B891ABF5C4251406A03",
-		"9B79374722AD888EB6A35A2DF25A8B3E",
-		"1034A6F98AF6625CC3E3604B59B971CA617DF337538D2179EBB22F3BDC9D0C6DA56BA7DDFD205A50",
-		"",
-		0x14));
-}
-
-void KeyVault::LoadSelfISOKeys()
-{
-	sk_ISO_arr.Clear();	
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0003003000000000, 0x0001, KEY_ISO,
-		"8860D0CFF4D0DC688D3223321B96B59A777E6914961488E07048DAECB020ECA4",
-		"C82D015D46CF152F1DD0C16F18B5B1E5",
-		"733918D7C888130509346E6B4A8B6CAA357AB557E814E8122BF102C14A314BF9475B9D70EAF9EC29",
-		"009BE892E122A5C943C1BB7403A67318AA9E1B286F",
-		0x36));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0003004200000000, 0x0001, KEY_ISO,
-		"101E27F3FA2FB53ACA924F783AD553162D56B975D05B81351A1111799F20254D",
-		"8D2E9C6297B8AD252998458296AC773C",
-		"138446EE0BDDA5638F97328C8956E6489CBBFE57C5961D40DD5C43BB4138F1C400A8B27204A5D625",
-		"00849DBC57D3B92F01864E6E82EB4EF0EF6311E122",
-		0x32));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0003005000000000, 0x0001, KEY_ISO,
-		"3F2604FA27AEADFBE1AC69EB00BB16EF196C2193CBD62900FFD8C25041680843",
-		"A414AC1DB7987E43777651B330B899E1",
-		"1F4633AFDE18614D6CEF38A2FD6C4CCAC7B6EB8109D72CD066ECEBA0193EA3F43C37AE83179A4E5F",
-		"0085B4B05DEBA7E6AD831653C974D95149803BB272",
-		0x33));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0003005500000000, 0x0001, KEY_ISO,
-		"BDB74AA6E3BA2DC10B1BD7F17198399A158DBE1FA0BEA68C90FCACBE4D04BE37",
-		"0207A479B1574F8E7F697528F05D5435",
-		"917E1F1DC48A54EB5F10B38E7569BB5383628A7C906F0DCA62FDA33805C15FAB270016940A09DB58",
-		"00294411363290975BA551336D3965D88AF029A17B",
-		0x03));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0003005600000000, 0x0001, KEY_ISO,
-		"311C015F169F2A1E0757F7064B14C7C9F3A3FFEE015BD4E3A22401A2667857CE",
-		"7BB8B3F5AC8E0890E3148AE5688C7350",
-		"3F040EFA2335FED5670BA4D5C3AB2D9D0B4BA69D154A0062EA995A7D21DBAF0DC5A0DAD333D1C1DD",
-		"",
-		0x08));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0003006100000000, 0x0001, KEY_ISO,
-		"8474ADCA3B3244931EECEB9357841442442A1C4A4BCF4E498E6738950F4E4093",
-		"FFF9CACCC4129125CAFB240F419E5F39",
-		"098E1A53E59A95316B00D5A29C05FFEBAE41D1A8A386F9DA96F98858FD25E07BB7A3BC96A5D5B556",
-		"",
-		0x03));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0003006600000000, 0x0001, KEY_ISO,
-		"E6A21C599B75696C169EC02582BDA74A776134A6E05108EA701EC0CA2AC03592",
-		"D292A7BD57C0BB2EABBCA1252FA9EDEF",
-		"2ED078A13DC4617EB550AD06E228C83C142A2D588EB5E729402D18038A14842FD65B277DCAD225A5",
-		"",
-		0x08));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0003007400000000, 0x0001, KEY_ISO,
-		"072D3A5C3BDB0D674DE209381432B20414BC9BDA0F583ECB94BD9A134176DD51",
-		"8516A81F02CF938740498A406C880871",
-		"5A778DEB5C4F12E8D48E06A2BBBBE3C90FA8C6C47DF9BDB5697FD4A8EB7941CE3F59A557E81C787D",
-		"",
-		0x21));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0003007400000000, 0x0100, KEY_ISO,
-		"786FAB8A0B89474A2CB80B3EA104CCCB9E13F66B45EC499BB31865D07C661EA8",
-		"94662F13D99A9F5D211C979FFDF65FE3",
-		"912C94C252B7799CEB45DFBB73EF7CAD9BCC0793A3331BBB79E3C47C0F5C782F698065A8D4DB0D8B",
-		"",
-		0x0E));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0004001100000000, 0x0001, KEY_ISO,
-		"4262657A3185D9480F82C8BD2F81766FCC2C8FD7DD5EBE8657B00B939E0C75BD",
-		"4F1E3EF07D893A4714B1B3D5A4E50479",
-		"4DBFCFA68B52F1D66E09AFA6C18EC65479EDBD027B6B8C6A5D85FE5C84D43EA40CEF1672078A0702",
-		"",
-		0x11));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0004001100000000, 0x0100, KEY_ISO,
-		"16AA7D7C35399E2B1BFAF68CD19D7512A7855029C08BECC4CC3F035DF7F9C70B",
-		"0E50DB6D937D262CB0499136852FCB80",
-		"AEE2795BF295662A50DFAFE70D1B0B6F0A2EBB211E1323A275FC6E2D13BE4F2F10CA34784F4CF1EC",
-		"",
-		0x0F));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0004005000000000, 0x0001, KEY_ISO,
-		"63565DBE98C3B1A52AADC907C47130FE57A10734E84F22592670F86ED2B0A086",
-		"953F6A99891B4739358F5363A00C08B9",
-		"26BE7B02E7D65C6C21BF4063CDB8C0092FE1679D62FA1A8CCC284A1D21885473A959992537A06612",
-		"",
-		0x15));
-	sk_ISO_arr.Move(
-		new SELF_KEY(0x0004005000000000, 0x0100, KEY_ISO,
-		"B96EA32CB96EA32DB96EA32CB96EA32CB96EA32CB96EA32DB96EA32CB96EA32C",
-		"B96EA32CB96EA32DB96EA32DB96EA32C",
-		"2D7066E68C6AC3373B1346FD76FE7D18A207C811500E65D85DB57BC4A27AD78F59FD53F38F50E151",
-		"0044AA25B4276D79B494A29CB8DE104642424F8EEF",
-		0x02));
-}
-
-void KeyVault::LoadSelfAPPKeys()
-{
-	sk_APP_arr.Clear();	
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0000009200000000, 0x0000, KEY_APP,
-		"95F50019E7A68E341FA72EFDF4D60ED376E25CF46BB48DFDD1F080259DC93F04",
-		"4A0955D946DB70D691A640BB7FAECC4C",
-		"6F8DF8EBD0A1D1DB08B30DD3A951E3F1F27E34030B42C729C55555232D61B834B8BDFFB07E54B343",
-		"006C3E4CCB2C69A5AD7C6F60448E50C7F9184EEAF4",
-		0x21));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003003000000000, 0x0001, KEY_APP,
-		"79481839C406A632BDB4AC093D73D99AE1587F24CE7E69192C1CD0010274A8AB",
-		"6F0F25E1C8C4B7AE70DF968B04521DDA",
-		"94D1B7378BAFF5DFED269240A7A364ED68446741622E50BC6079B6E606A2F8E0A4C56E5CFF836526",
-		"003DE80167D2F0E9D30F2145144A558D1174F5410C",
-		0x11));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003003000000000, 0x0002, KEY_APP,
-		"4F89BE98DDD43CAD343F5BA6B1A133B0A971566F770484AAC20B5DD1DC9FA06A",
-		"90C127A9B43BA9D8E89FE6529E25206F",
-		"8CA6905F46148D7D8D84D2AFCEAE61B41E6750FC22EA435DFA61FCE6F4F860EE4F54D9196CA5290E",
-		"",
-		0x13));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003003000000000, 0x0003, KEY_APP,
-		"C1E6A351FCED6A0636BFCB6801A0942DB7C28BDFC5E0A053A3F52F52FCE9754E",
-		"E0908163F457576440466ACAA443AE7C",
-		"50022D5D37C97905F898E78E7AA14A0B5CAAD5CE8190AE5629A10D6F0CF4173597B37A95A7545C92",
-		"",
-		0x0B));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003004200000000, 0x0004, KEY_APP,
-		"838F5860CF97CDAD75B399CA44F4C214CDF951AC795298D71DF3C3B7E93AAEDA",
-		"7FDBB2E924D182BB0D69844ADC4ECA5B",
-		"1F140E8EF887DAB52F079A06E6915A6460B75CD256834A43FA7AF90C23067AF412EDAFE2C1778D69",
-		"0074E922FDEE5DC4CDF22FC8D7986477F813400860",
-		0x14));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003004200000000, 0x0005, KEY_APP,
-		"C109AB56593DE5BE8BA190578E7D8109346E86A11088B42C727E2B793FD64BDC",
-		"15D3F191295C94B09B71EBDE088A187A",
-		"B6BB0A84C649A90D97EBA55B555366F52381BB38A84C8BB71DA5A5A0949043C6DB249029A43156F7",
-		"",
-		0x15));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003004200000000, 0x0006, KEY_APP,
-		"6DFD7AFB470D2B2C955AB22264B1FF3C67F180983B26C01615DE9F2ECCBE7F41",
-		"24BD1C19D2A8286B8ACE39E4A37801C2",
-		"71F46AC33FF89DF589A100A7FB64CEAC244C9A0CBBC1FDCE80FB4BF8A0D2E66293309CB8EE8CFA95",
-		"",
-		0x2C));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003005000000000, 0x0007, KEY_APP,
-		"945B99C0E69CAF0558C588B95FF41B232660ECB017741F3218C12F9DFDEEDE55",
-		"1D5EFBE7C5D34AD60F9FBC46A5977FCE",
-		"AB284CA549B2DE9AA5C903B75652F78D192F8F4A8F3CD99209415C0A84C5C9FD6BF3095C1C18FFCD",
-		"002CF896D35DB871D0E6A252E799876A70D043C23E",
-		0x15));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003005000000000, 0x0008, KEY_APP,
-		"2C9E8969EC44DFB6A8771DC7F7FDFBCCAF329EC3EC070900CABB23742A9A6E13",
-		"5A4CEFD5A9C3C093D0B9352376D19405",
-		"6E82F6B54A0E9DEBE4A8B3043EE3B24CD9BBB62B4416B0482582E419A2552E29AB4BEA0A4D7FA2D5",
-		"",
-		0x16));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003005000000000, 0x0009, KEY_APP,
-		"F69E4A2934F114D89F386CE766388366CDD210F1D8913E3B973257F1201D632B",
-		"F4D535069301EE888CC2A852DB654461",
-		"1D7B974D10E61C2ED087A0981535904677EC07E96260F89565FF7EBDA4EE035C2AA9BCBDD5893F99",
-		"",
-		0x2D));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003005500000000, 0x000A, KEY_APP,
-		"29805302E7C92F204009161CA93F776A072141A8C46A108E571C46D473A176A3",
-		"5D1FAB844107676ABCDFC25EAEBCB633",
-		"09301B6436C85B53CB1585300A3F1AF9FB14DB7C30088C4642AD66D5C148B8995BB1A698A8C71827",
-		"0010818ED8A666051C6198662C3D6DDE2CA4901DDC",
-		0x25));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003005500000000, 0x000B, KEY_APP,
-		"A4C97402CC8A71BC7748661FE9CE7DF44DCE95D0D58938A59F47B9E9DBA7BFC3",
-		"E4792F2B9DB30CB8D1596077A13FB3B5",
-		"2733C889D289550FE00EAA5A47A34CEF0C1AF187610EB07BA35D2C09BB73C80B244EB4147700D1BF",
-		"",
-		0x26));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003005500000000, 0x000C, KEY_APP,
-		"9814EFFF67B7074D1B263BF85BDC8576CE9DEC914123971B169472A1BC2387FA",
-		"D43B1FA8BE15714B3078C23908BB2BCA",
-		"7D1986C6BEE6CE1E0C5893BD2DF203881F40D5056761CC3F1F2E9D9A378617A2DE40BA5F09844CEB",
-		"",
-		0x3D));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003005600000000, 0x000D, KEY_APP,
-		"03B4C421E0C0DE708C0F0B71C24E3EE04306AE7383D8C5621394CCB99FF7A194",
-		"5ADB9EAFE897B54CB1060D6885BE22CF",
-		"71502ADB5783583AB88B2D5F23F419AF01C8B1E72FCA1E694AD49FE3266F1F9C61EFC6F29B351142",
-		"",
-		0x12));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003005600000000, 0x000E, KEY_APP,
-		"39A870173C226EB8A3EEE9CA6FB675E82039B2D0CCB22653BFCE4DB013BAEA03",
-		"90266C98CBAA06C1BF145FF760EA1B45",
-		"84DE5692809848E5ACBE25BE548F6981E3DB14735A5DDE1A0FD1F475866532B862B1AB6A004B7255",
-		"",
-		0x27));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003005600000000, 0x000F, KEY_APP,
-		"FD52DFA7C6EEF5679628D12E267AA863B9365E6DB95470949CFD235B3FCA0F3B",
-		"64F50296CF8CF49CD7C643572887DA0B",
-		"0696D6CCBD7CF585EF5E00D547503C185D7421581BAD196E081723CD0A97FA40B2C0CD2492B0B5A1",
-		"",
-		0x3A));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003006100000000, 0x0010, KEY_APP,
-		"A5E51AD8F32FFBDE808972ACEE46397F2D3FE6BC823C8218EF875EE3A9B0584F",
-		"7A203D5112F799979DF0E1B8B5B52AA4",
-		"50597B7F680DD89F6594D9BDC0CBEE03666AB53647D0487F7F452FE2DD02694631EA755548C9E934",
-		"",
-		0x25));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003006100000000, 0x0011, KEY_APP,
-		"0F8EAB8884A51D092D7250597388E3B8B75444AC138B9D36E5C7C5B8C3DF18FD",
-		"97AF39C383E7EF1C98FA447C597EA8FE",
-		"2FDA7A56AAEA65921C0284FF1942C6DE137370093D106034B59191951A5201B422D462F8726F852D",
-		"",
-		0x26));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003006600000000, 0x0013, KEY_APP,
-		"DBF62D76FC81C8AC92372A9D631DDC9219F152C59C4B20BFF8F96B64AB065E94",
-		"CB5DD4BE8CF115FFB25801BC6086E729",
-		"B26FE6D3E3A1E766FAE79A8E6A7F48998E7FC1E4B0AD8745FF54C018C2A6CC7A0DD7525FAFEA4917",
-		"",
-		0x12));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003006600000000, 0x0014, KEY_APP,
-		"491B0D72BB21ED115950379F4564CE784A4BFAABB00E8CB71294B192B7B9F88E",
-		"F98843588FED8B0E62D7DDCB6F0CECF4",
-		"04275E8838EF95BD013B223C3DF674540932F21B534C7ED2944B9104D938FEB03B824DDB866AB26E",
-		"",
-		0x27));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003007400000000, 0x0016, KEY_APP,
-		"A106692224F1E91E1C4EBAD4A25FBFF66B4B13E88D878E8CD072F23CD1C5BF7C",
-		"62773C70BD749269C0AFD1F12E73909E",
-		"566635D3E1DCEC47243AAD1628AE6B2CEB33463FC155E4635846CE33899C5E353DDFA47FEF5694AF",
-		"",
-		0x30));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003007400000000, 0x0017, KEY_APP,
-		"4E104DCE09BA878C75DA98D0B1636F0E5F058328D81419E2A3D22AB0256FDF46",
-		"954A86C4629E116532304A740862EF85",
-		"3B7B04C71CAE2B1199D57453C038BB1B541A05AD1B94167B0AB47A9B24CAECB9000CB21407009666",
-		"",
-		0x08));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0003007400000000, 0x0018, KEY_APP,
-		"1F876AB252DDBCB70E74DC4A20CD8ED51E330E62490E652F862877E8D8D0F997",
-		"BF8D6B1887FA88E6D85C2EDB2FBEC147",
-		"64A04126D77BF6B4D686F6E8F87DD150A5B014BA922D2B694FFF4453E11239A6E0B58F1703C51494",
-		"",
-		0x11));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0004001100000000, 0x0019, KEY_APP,
-		"3236B9937174DF1DC12EC2DD8A318A0EA4D3ECDEA5DFB4AC1B8278447000C297",
-		"6153DEE781B8ADDC6A439498B816DC46",
-		"148DCA961E2738BAF84B2D1B6E2DA2ABD6A95F2C9571E54C6922F9ED9674F062B7F1BE5BD6FA5268",
-		"",
-		0x31));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0004001100000000, 0x001A, KEY_APP,
-		"5EFD1E9961462794E3B9EF2A4D0C1F46F642AAE053B5025504130590E66F19C9",
-		"1AC8FA3B3C90F8FDE639515F91B58327",
-		"BE4B1B513536960618BFEF12A713F6673881B02F9DC616191E823FC8337CCF99ADAA6172019C0C23",
-		"",
-		0x17));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0004001100000000, 0x001B, KEY_APP,
-		"66637570D1DEC098467DB207BAEA786861964D0964D4DBAF89E76F46955D181B",
-		"9F7B5713A5ED59F6B35CD8F8A165D4B8",
-		"4AB6FB1F6F0C3D9219923C1AC683137AB05DF667833CC6A5E8F590E4E28FE2EB180C7D5861117CFB",
-		"",
-		0x12));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0004004600000000, 0x001C, KEY_APP,
-		"CFF025375BA0079226BE01F4A31F346D79F62CFB643CA910E16CF60BD9092752",
-		"FD40664E2EBBA01BF359B0DCDF543DA4",
-		"36C1ACE6DD5CCC0006FDF3424750FAC515FC5CFA2C93EC53C6EC2BC421708D154E91F2E7EA54A893",
-		"",
-		0x09));
-	sk_APP_arr.Move(
-		new SELF_KEY(0x0004004600000000, 0x001D, KEY_APP,
-		"D202174EB65A62048F3674B59EF6FE72E1872962F3E1CD658DE8D7AF71DA1F3E",
-		"ACB9945914EBB7B9A31ECE320AE09F2D",
-		"430322887503CF52928FAAA410FD623C7321281C8825D95F5B47EF078EFCFC44454C3AB4F00BB879",
-		"",
-		0x1A));
-}
-
-void KeyVault::LoadSelfNPDRMKeys()
-{
-	sk_NPDRM_arr.Clear();	
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0001000000000000, 0x0001, KEY_NPDRM,
-		"F9EDD0301F770FABBA8863D9897F0FEA6551B09431F61312654E28F43533EA6B",
-		"A551CCB4A42C37A734A2B4F9657D5540",
-		"B05F9DA5F9121EE4031467E74C505C29A8E29D1022379EDFF0500B9AE480B5DAB4578A4C61C5D6BF",
-		"00040AB47509BED04BD96521AD1B365B86BF620A98",
-		0x11));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0001000000000000, 0x0002, KEY_NPDRM,
-		"8E737230C80E66AD0162EDDD32F1F774EE5E4E187449F19079437A508FCF9C86",
-		"7AAECC60AD12AED90C348D8C11D2BED5",
-		"05BF09CB6FD78050C78DE69CC316FF27C9F1ED66A45BFCE0A1E5A6749B19BD546BBB4602CF373440",
-		"",
-		0x0A));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003003000000000, 0x0003, KEY_NPDRM,
-		"1B715B0C3E8DC4C1A5772EBA9C5D34F7CCFE5B82025D453F3167566497239664",
-		"E31E206FBB8AEA27FAB0D9A2FFB6B62F",
-		"3F51E59FC74D6618D34431FA67987FA11ABBFACC7111811473CD9988FE91C43FC74605E7B8CB732D",
-		"",
-		0x08));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003004200000000, 0x0004, KEY_NPDRM,
-		"BB4DBF66B744A33934172D9F8379A7A5EA74CB0F559BB95D0E7AECE91702B706",
-		"ADF7B207A15AC601110E61DDFC210AF6",
-		"9C327471BAFF1F877AE4FE29F4501AF5AD6A2C459F8622697F583EFCA2CA30ABB5CD45D1131CAB30",
-		"00B61A91DF4AB6A9F142C326BA9592B5265DA88856",
-		0x16));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003004200000000, 0x0006, KEY_NPDRM,
-		"8B4C52849765D2B5FA3D5628AFB17644D52B9FFEE235B4C0DB72A62867EAA020",
-		"05719DF1B1D0306C03910ADDCE4AF887",
-		"2A5D6C6908CA98FC4740D834C6400E6D6AD74CF0A712CF1E7DAE806E98605CC308F6A03658F2970E",
-		"",
-		0x29));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003005000000000, 0x0007, KEY_NPDRM,
-		"3946DFAA141718C7BE339A0D6C26301C76B568AEBC5CD52652F2E2E0297437C3",
-		"E4897BE553AE025CDCBF2B15D1C9234E",
-		"A13AFE8B63F897DA2D3DC3987B39389DC10BAD99DFB703838C4A0BC4E8BB44659C726CFD0CE60D0E",
-		"009EF86907782A318D4CC3617EBACE2480E73A46F6",
-		0x17));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003005000000000, 0x0009, KEY_NPDRM,
-		"0786F4B0CA5937F515BDCE188F569B2EF3109A4DA0780A7AA07BD89C3350810A",
-		"04AD3C2F122A3B35E804850CAD142C6D",
-		"A1FE61035DBBEA5A94D120D03C000D3B2F084B9F4AFA99A2D4A588DF92B8F36327CE9E47889A45D0",
-		"",
-		0x2A));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003005500000000, 0x000A, KEY_NPDRM,
-		"03C21AD78FBB6A3D425E9AAB1298F9FD70E29FD4E6E3A3C151205DA50C413DE4",
-		"0A99D4D4F8301A88052D714AD2FB565E",
-		"3995C390C9F7FBBAB124A1C14E70F9741A5E6BDF17A605D88239652C8EA7D5FC9F24B30546C1E44B",
-		"009AC6B22A056BA9E0B6D1520F28A57A3135483F9F",
-		0x27));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003005500000000, 0x000C, KEY_NPDRM,
-		"357EBBEA265FAEC271182D571C6CD2F62CFA04D325588F213DB6B2E0ED166D92",
-		"D26E6DD2B74CD78E866E742E5571B84F",
-		"00DCF5391618604AB42C8CFF3DC304DF45341EBA4551293E9E2B68FFE2DF527FFA3BE8329E015E57",
-		"",
-		0x3A));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003005600000000, 0x000D, KEY_NPDRM,
-		"337A51416105B56E40D7CAF1B954CDAF4E7645F28379904F35F27E81CA7B6957",
-		"8405C88E042280DBD794EC7E22B74002",
-		"9BFF1CC7118D2393DE50D5CF44909860683411A532767BFDAC78622DB9E5456753FE422CBAFA1DA1",
-		"",
-		0x18));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003005600000000, 0x000F, KEY_NPDRM,
-		"135C098CBE6A3E037EBE9F2BB9B30218DDE8D68217346F9AD33203352FBB3291",
-		"4070C898C2EAAD1634A288AA547A35A8",
-		"BBD7CCCB556C2EF0F908DC7810FAFC37F2E56B3DAA5F7FAF53A4944AA9B841F76AB091E16B231433",
-		"",
-		0x3B));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003006100000000, 0x0010, KEY_NPDRM,
-		"4B3CD10F6A6AA7D99F9B3A660C35ADE08EF01C2C336B9E46D1BB5678B4261A61",
-		"C0F2AB86E6E0457552DB50D7219371C5",
-		"64A5C60BC2AD18B8A237E4AA690647E12BF7A081523FAD4F29BE89ACAC72F7AB43C74EC9AFFDA213",
-		"",
-		0x27));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003006600000000, 0x0013, KEY_NPDRM,
-		"265C93CF48562EC5D18773BEB7689B8AD10C5EB6D21421455DEBC4FB128CBF46",
-		"8DEA5FF959682A9B98B688CEA1EF4A1D",
-		"9D8DB5A880608DC69717991AFC3AD5C0215A5EE413328C2ABC8F35589E04432373DB2E2339EEF7C8",
-		"",
-		0x18));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0003007400000000, 0x0016, KEY_NPDRM,
-		"7910340483E419E55F0D33E4EA5410EEEC3AF47814667ECA2AA9D75602B14D4B",
-		"4AD981431B98DFD39B6388EDAD742A8E",
-		"62DFE488E410B1B6B2F559E4CB932BCB78845AB623CC59FDF65168400FD76FA82ED1DC60E091D1D1",
-		"",
-		0x25));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0004001100000000, 0x0019, KEY_NPDRM,
-		"FBDA75963FE690CFF35B7AA7B408CF631744EDEF5F7931A04D58FD6A921FFDB3",
-		"F72C1D80FFDA2E3BF085F4133E6D2805",
-		"637EAD34E7B85C723C627E68ABDD0419914EBED4008311731DD87FDDA2DAF71F856A70E14DA17B42",
-		"",
-		0x24));
-	sk_NPDRM_arr.Move(
-		new SELF_KEY(0x0004004600000000, 0x001C, KEY_NPDRM,
-		"8103EA9DB790578219C4CEDF0592B43064A7D98B601B6C7BC45108C4047AA80F",
-		"246F4B8328BE6A2D394EDE20479247C5",
-		"503172C9551308A87621ECEE90362D14889BFED2CF32B0B3E32A4F9FE527A41464B735E1ADBC6762",
-		"",
-		0x30));
-}
-
-void KeyVault::LoadSelfUNK7Keys()
-{
-	sk_UNK7_arr.Clear();	
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0003003000000000, 0x0000, KEY_UNK7,
-		"D91166973979EA8694476B011AC62C7E9F37DA26DE1E5C2EE3D66E42B8517085",
-		"DC01280A6E46BC674B81A7E8801EBE6E",
-		"A0FC44108236141BF3517A662B027AFC1AC513A05690496C754DEB7D43BDC41B80FD75C212624EE4",
-		"",
-		0x11));
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0003004200000000, 0x0000, KEY_UNK7,
-		"B73111B0B00117E48DE5E2EE5E534C0F0EFFA4890BBB8CAD01EE0F848F91583E",
-		"86F56F9E5DE513894874B8BA253334B1",
-		"B0BA1A1AB9723BB4E87CED9637BE056066BC56E16572D43D0210A06411DBF8FEB8885CD912384AE5",
-		"",
-		0x12));
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0003005000000000, 0x0000, KEY_UNK7,
-		"8E944267C02E69A4FE474B7F5FCD7974A4F936FF4355AEC4F80EFA123858D8F6",
-		"908A75754E521EAC2F5A4889C6D7B72D",
-		"91201DA7D79E8EE2563142ECBD646DA026C963AC09E760E5390FFE24DAE6864310ABE147F8204D0B",
-		"",
-		0x13));
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0003005500000000, 0x0000, KEY_UNK7,
-		"BB31DF9A6F62C0DF853075FAA65134D9CE2240306C1731D1F7DA9B5329BD699F",
-		"263057225873F83940A65C8C926AC3E4",
-		"BC3A82A4F44C43A197070CD236FDC94FCC542D69A3E803E0AFF78D1F3DA19A79D2F61FAB5B94B437",
-		"",
-		0x23));
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0003005600000000, 0x0000, KEY_UNK7,
-		"71AA75C70A255580E4AE9BDAA0B08828C53EAA713CD0713797F143B284C1589B",
-		"9DED878CB6BA07121C0F50E7B172A8BF",
-		"387FCDAEAFF1B59CFAF79CE6215A065ACEAFFAF4048A4F217E1FF5CE67C66EC3F089DB235E52F9D3",
-		"",
-		0x29));
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0003006100000000, 0x0000, KEY_UNK7,
-		"F5D1DBC182F5083CD4EA37C431C7DAC73882C07F232D2699B1DD9FDDF1BF4195",
-		"D3A7C3C91CBA014FCBCA6D5570DE13FF",
-		"97CA8A9781F45E557E98F176EF794FCDA6B151EB3DFD1ABA12151E00AE59957C3B15628FC8875D28",
-		"",
-		0x23));
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0003006600000000, 0x0000, KEY_UNK7,
-		"BF10F09590C0152F7EF749FF4B990122A4E8E5491DA49A2D931E72EEB990F860",
-		"22C19C5522F7A782AFC547C2640F5BDE",
-		"3233BA2B284189FB1687DF653002257A0925D8EB0C64EBBE8CC7DE87F548D107DE1FD3D1D285DB4F",
-		"",
-		0x29));
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0003007400000000, 0x0000, KEY_UNK7,
-		"F11DBD2C97B32AD37E55F8E743BC821D3E67630A6784D9A058DDD26313482F0F",
-		"FC5FA12CA3D2D336C4B8B425D679DA55",
-		"19E27EE90E33EDAB16B22E688B5F704E5C6EC1062070EBF43554CD03DFDAE16D684BB8B5574DBECA",
-		"",
-		0x15));
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0004001100000000, 0x0000, KEY_UNK7,
-		"751EE949CD3ADF50A469197494A1EC358409CCBE6E85217EBDE7A87D3FF1ABD8",
-		"23AE4ADA4D3F798DC5ED98000337FF77",
-		"1BABA87CD1AD705C462D4E7427B6DAF59A50383A348A15088F0EDFCF1ADF2B5C2B2D507B2A357D36",
-		"",
-		0x1A));
-	sk_UNK7_arr.Move(
-		new SELF_KEY(0x0004004600000000, 0x0000, KEY_UNK7,
-		"46BD0891224E0CE13E2162921D4BB76193AEEE4416A729FCDD111C5536BF87C9",
-		"BF036387CDB613C0AC88A6D9D2CC5316",
-		"A14F6D5F9AD7EBB3B7A39A7C32F13E5DC3B0BA16BDC33D39FDDF88F4AEEA6CFEEB0C0796C917A952",
-		"",
-		0x0F));
-}
-
-SELF_KEY KeyVault::GetSelfLV0Key()
-{
-	return sk_LV0_arr[0];
-}
-
-SELF_KEY KeyVault::GetSelfLDRKey()
-{
-	return sk_LDR_arr[0];
-}
-
-SELF_KEY KeyVault::GetSelfLV1Key(u64 version)
-{
-	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
-
-	for(unsigned int i = 0; i < sk_LV1_arr.GetCount(); i++)
-	{
-		if (sk_LV1_arr[i].version == version)
-		{
-			key = sk_LV1_arr[i];
-			break;
-		}
-	}
-
-	return key;
-}
-
-SELF_KEY KeyVault::GetSelfLV2Key(u64 version)
-{
-	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
-
-	for(unsigned int i = 0; i < sk_LV2_arr.GetCount(); i++)
-	{
-		if (sk_LV2_arr[i].version == version)
-		{
-			key = sk_LV2_arr[i];
-			break;
-		}
-	}
-
-	return key;
-}
-
-SELF_KEY KeyVault::GetSelfISOKey(u16 revision, u64 version)
-{
-	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
-
-	for(unsigned int i = 0; i < sk_ISO_arr.GetCount(); i++)
-	{
-		if ((sk_ISO_arr[i].version == version) &&
-			(sk_ISO_arr[i].revision == revision))
-		{
-			key = sk_ISO_arr[i];
-			break;
-		}
-	}
-
-	return key;
-}
-
-SELF_KEY KeyVault::GetSelfAPPKey(u16 revision)
-{
-	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
-
-	for(unsigned int i = 0; i < sk_APP_arr.GetCount(); i++)
-	{
-		if (sk_APP_arr[i].revision == revision)
-		{
-			key = sk_APP_arr[i];
-			break;
-		}
-	}
-
-	return key;
-}
-
-SELF_KEY KeyVault::GetSelfUNK7Key(u64 version)
-{
-	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
-
-	for(unsigned int i = 0; i < sk_UNK7_arr.GetCount(); i++)
-	{
-		if (sk_UNK7_arr[i].version == version)
-		{
-			key = sk_UNK7_arr[i];
-			break;
-		}
-	}
-
-	return key;
-}
-
-SELF_KEY KeyVault::GetSelfNPDRMKey(u16 revision)
-{
-	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
-
-	for(unsigned int i = 0; i < sk_NPDRM_arr.GetCount(); i++)
-	{
-		if (sk_NPDRM_arr[i].revision == revision)
-		{
-			key = sk_NPDRM_arr[i];
-			break;
-		}
-	}
-
-	return key;
-}
-
-SELF_KEY KeyVault::FindSelfKey(u32 type, u16 revision, u64 version)
-{
-	// Empty key.
-	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
-	
-	// Check SELF type.
-	switch (type)
-	{
-	case KEY_LV0:
-		LoadSelfLV0Keys();
-		key = GetSelfLV0Key();
-		break;
-	case KEY_LV1:
-		LoadSelfLV1Keys();
-		key = GetSelfLV1Key(version);
-		break;
-	case KEY_LV2:
-		LoadSelfLV2Keys();
-		key = GetSelfLV2Key(version);
-		break;
-	case KEY_APP:
-		LoadSelfAPPKeys();
-		key = GetSelfAPPKey(revision);
-		break;
-	case KEY_ISO:
-		LoadSelfISOKeys();
-		key = GetSelfISOKey(revision, version);
-		break;
-	case KEY_LDR:
-		LoadSelfLDRKeys();
-		key = GetSelfLDRKey();
-		break;
-	case KEY_UNK7:
-		LoadSelfUNK7Keys();
-		key = GetSelfUNK7Key(version);
-		break;
-	case KEY_NPDRM:
-		LoadSelfNPDRMKeys();
-		key = GetSelfNPDRMKey(revision);
-		break;
-	default:
-		break;
-	}
-
-	return key;
-}
-
-void KeyVault::SetKlicenseeKey(u8 *key)
-{
-	memcpy(klicensee_key, key, 0x10);
-}
-
-u8 *KeyVault::GetKlicenseeKey()
-{
-	return klicensee_key;
-}
+#include "stdafx.h"
+#include "key_vault.h"
+
+KeyVault::KeyVault()
+{
+}
+
+void KeyVault::LoadSelfLV0Keys()
+{
+	sk_LV0_arr.clear();
+	sk_LV0_arr.emplace_back(0x0000000000000000, 0x0000, KEY_LV0,
+		"CA7A24EC38BDB45B98CCD7D363EA2AF0C326E65081E0630CB9AB2D215865878A",
+		"F9205F46F6021697E670F13DFA726212",
+		"A8FD6DB24532D094EFA08CB41C9A72287D905C6B27B42BE4AB925AAF4AFFF34D41EEB54DD128700D",
+		"001AD976FCDE86F5B8FF3E63EF3A7F94E861975BA3",
+		0x33);
+}
+
+void KeyVault::LoadSelfLDRKeys()
+{
+	sk_LDR_arr.clear();
+	sk_LDR_arr.emplace_back(0x0000000000000000, 0x0000, KEY_LDR,
+		"C0CEFE84C227F75BD07A7EB846509F93B238E770DACB9FF4A388F812482BE21B",
+		"47EE7454E4774CC9B8960C7B59F4C14D",
+		"C2D4AAF319355019AF99D44E2B58CA29252C89123D11D6218F40B138CAB29B7101F3AEB72A975019",
+		"00C5B2BFA1A413DD16F26D31C0F2ED4720DCFB0670",
+		0x20);
+}
+
+void KeyVault::LoadSelfLV1Keys()
+{
+	sk_LV1_arr.clear();
+	sk_LV1_arr.emplace_back(0x0003003000000000, 0x0000, KEY_LV1,
+		"B9F3F9E6107CFF2680A91E118C2403CF4A6F18F3C7EFD7D13D1AC4DB760BD222",
+		"B43661B9A79BAD9D8E2B046469CDA1E7",
+		"4C870BE86DDD996A92A3F7F404F33604244A1D02AB5B78BC9DAF030B78BE8867CF586171B7D45D20",
+		"002CC736C7AD06D264E9AB663EB1F35F5DC159248C",
+		0x33);
+	sk_LV1_arr.emplace_back(0x0003004200000000, 0x0000, KEY_LV1,
+		"B880593856C8C6D2037585626A12977F50DCFCF3F132D2C89AA6E670EAFC1646",
+		"A79B05D4E37B8117A95E6E7C14FB640E",
+		"7454C7CCBFC2F66C142D78A730A3A6F973CC0FB75A46FCBB390790138910A0CAC78E5E21F4DA3375",
+		"00033A699FDD2DA6CDD6CCC03B2C6145F998706F74",
+		0x34);
+	sk_LV1_arr.emplace_back(0x0003005000000000, 0x0000, KEY_LV1,
+		"1E8EEEA9E80A729F3FA52CF523B25941EA44B4155D94E5DADC5C5A77847620C7",
+		"E034D31A80316960024D1B3D3164FDC3",
+		"7E3A196f4A5879F3A7B091A2263F7C24E1716129B580566D308D9C2254B36AEE53DEF30EC85F8398",
+		"005815D17125D04C33790321DE29EB6241365100B5",
+		0x35);
+	sk_LV1_arr.emplace_back(0x0003005500000000, 0x0000, KEY_LV1,
+		"53ABDF84BE08B0351B734F2B97D2BE1621BC6C889E4362E5C70F39D6C3ED9F23",
+		"44E652661AC7584DBE08ECB810FB5FC0",
+		"733198A7759BC07326755BC9773A8A17C8A7043C7BDAB83D88E230512E2EA3852D7DA4263A7E97F9",
+		"004312C65347ACBE95CC306442FEFD0AF4C2935EB3",
+		0x05);
+	sk_LV1_arr.emplace_back(0x0003005600000000, 0x0000, KEY_LV1,
+		"48793EBDDA1AF65D737DA2FDA2DD104447A698F8A82CAAEE992831711BA94E83",
+		"15DCF3C67147A45D09DE7521EECA07A1",
+		"85A8868C320127F10B6598964C69221C086702021D31803520E21FDE4DBE827766BE41825CB7328C",
+		"",
+		0x07);
+	sk_LV1_arr.emplace_back(0x0003006100000000, 0x0000, KEY_LV1,
+		"5FF17D836E2C4AD69476E2614F64BDD05B9115389A9A6D055B5B544B1C34E3D5",
+		"DF0F50EC3C4743C5B17839D7B49F24A4",
+		"1CDABE30833823F461CA534104115FFF60010B710631E435A7D915E82AE88EDE667264656CB7062E",
+		"",
+		0x05);
+	sk_LV1_arr.emplace_back(0x0003006600000000, 0x0000, KEY_LV1,
+		"BD0621FA19383C3C72ECBC3B008F1CD55FFD7C3BB7510BF11AD0CF0FC2B70951",
+		"569AF3745E1E02E3E288273CDE244CD8",
+		"21E26F11C2D69478609DD1BD278CDFC940D90386455BA52FCD1FA7E27AC2AFA826C79A10193B625C",
+		"",
+		0x07);
+	sk_LV1_arr.emplace_back(0x0003007400000000, 0x0000, KEY_LV1,
+		"41A6E0039041E9D8AAF4EF2F2A2971248EDBD96A3985611ED7B4CE73EE4804FE",
+		"C8C98D5A5CE23AF5607A352AECACB0DC",
+		"4389664390265F96C1A882374C0F856364E33DB09BE124A4666F9A12F0DD9C811EDD55BA21ED0667",
+		"",
+		0x12);
+	sk_LV1_arr.emplace_back(0x0004001100000000, 0x0000, KEY_LV1,
+		"557EDF6C063F3272B0D44EEC12F418DA774815B5415597CC5F75C21E048BAD74",
+		"7144D7574937818517826227EF4AC0B4",
+		"085D38DBF9B757329EB862107929909D32FA1DAE60641BF4AC25319D7650597EE977F8E810FEEA96",
+		"",
+		0x13);
+	sk_LV1_arr.emplace_back(0x0004005000000000, 0x0000, KEY_LV1,
+		"10CEA04973FCCC12EC19924510822D8D4C41F657FD3D7E73F415A8D687421BCD",
+		"ED8699562C6AC65204FA166257E7FCF4",
+		"9AF86FC869C159FBB62F7D9674EE257ABF12E5A96D5875B4AA73C13C2BC13E2A4079F98B9B935EE2",
+		"",
+		0x14);
+}
+
+void KeyVault::LoadSelfLV2Keys()
+{
+	sk_LV2_arr.clear();
+	sk_LV2_arr.emplace_back(0x0003003000000000, 0x0000, KEY_LV2,
+		"94303F69513572AB5AE17C8C2A1839D2C24C28F65389D3BBB11894CE23E0798F",
+		"9769BFD187B90990AE5FEA4E110B9CF5",
+		"AFAF5E96AF396CBB69071082C46A8F34A030E8EDB799E0A7BE00AA264DFF3AEBF7923920D559404D",
+		"0070ABF9361B02291829D479F56AB248203CD3EB46",
+		0x20);
+	sk_LV2_arr.emplace_back(0x0003004200000000, 0x0000, KEY_LV2,
+		"575B0A6C4B4F2760A03FE4189EBAF4D947279FD982B14070349098B08FF92C10",
+		"411CB18F460CE50CAF2C426D8F0D93C8",
+		"3FEE313954CB3039C321A7E33B97FFDEC8988A8B55759161B04DBF4731284E4A8191E3F17D32B0EA",
+		"0073076441A08CD179E5FACE349B86DA58B5B7BA78",
+		0x21);
+	sk_LV2_arr.emplace_back(0x0003005000000000, 0x0000, KEY_LV2,
+		"6DBD48D787C58803A8D724DA5ACF04FF8FCE91D7545D2322F2B7ABF57014AF68",
+		"603A36213708520ED5D745DEC1325BA5",
+		"5888CB83AC3CCA9610BC173C53141C0CA58B93719E744660CA8823D5EAEE8F9BF736997054E4B7E3",
+		"0009EBC3DE442FA5FBF6C4F3D4F9EAB07778A142BD",
+		0x22);
+	sk_LV2_arr.emplace_back(0x0003005500000000, 0x0000, KEY_LV2,
+		"84015E90FA23139628A3C75CC09714E6427B527A82D18ABC3E91CD8D7DDAFF17",
+		"5B240444D645F2038118F97FD5A145D5",
+		"B266318245266B2D33641CD8A864066D077FAC60B7E27399099A70A683454B70F9888E7CC0C2BF72",
+		"009D4CBA2BFB1A8330D3E20E59D281D476D231C73A",
+		0x32);
+	sk_LV2_arr.emplace_back(0x0003005600000000, 0x0000, KEY_LV2,
+		"EAE15444048EFDE7A831BFA9F5D96F047C9FCFF50723E292CF50F5417D81E359",
+		"9CA9282DC7FA9F315EF3156D970B7CD4",
+		"0D58938CB47598A6A672874F1768068F8B80D8D17014D2ABEBAC85E5B0993D9FB6F307DDC3DDA699",
+		"",
+		0x33);
+	sk_LV2_arr.emplace_back(0x0003006100000000, 0x0000, KEY_LV2,
+		"88AD367EDEC2FEED3E2F99B1C685075C41BDEC90C84F526CAF588F89BBD1CBCC",
+		"8D18E8E525230E63DE10291C9DD615BF",
+		"86EED1D65E58890ABDA9ACA486A2BDDB9C0A529C2053FAE301F0F698EAF443DA0F60595A597A7027",
+		"",
+		0x32);
+	sk_LV2_arr.emplace_back(0x0003006600000000, 0x0000, KEY_LV2,
+		"688D5FCAC6F4EA35AC6AC79B10506007286131EE038116DB8AA2C0B0340D9FB0",
+		"75E0239D18B0B669EAE650972F99726B",
+		"008E1C820AC567D1BFB8FE3CC6AD2E1845A1D1B19ED2E18B18CA34A8D28A83EC60C63859CDB3DACA",
+		"",
+		0x33);
+	sk_LV2_arr.emplace_back(0x0003007400000000, 0x0000, KEY_LV2,
+		"E81C5B04C29FB079A4A2687A39D4EA97BFB49D80EF546CEB292979A5F77A6254",
+		"15058FA7F2CAD7C528B5F605F6444EB0",
+		"438D0E5C1E7AFB18234DB6867472FF5F52B750F30C379C7DD1EE0FD23E417B3EA819CC01BAC480ED",
+		"",
+		0x11);
+	sk_LV2_arr.emplace_back(0x0004001100000000, 0x0000, KEY_LV2,
+		"A1E4B86ED02BF7F1372A2C73FE02BC738907EB37CE3BA605FE783C999FAFDB97",
+		"BBE7799B9A37CB272E386618FDFD4AEC",
+		"5B31A8E2A663EBD673196E2E1022E0D64988C4E1BBFE5E474415883A3BA0D9C562A2BE9C30E9B4A8",
+		"",
+		0x07);
+	sk_LV2_arr.emplace_back(0x0004005000000000, 0x0000, KEY_LV2,
+		"0CAF212B6FA53C0DA7E2C575ADF61DBE68F34A33433B1B891ABF5C4251406A03",
+		"9B79374722AD888EB6A35A2DF25A8B3E",
+		"1034A6F98AF6625CC3E3604B59B971CA617DF337538D2179EBB22F3BDC9D0C6DA56BA7DDFD205A50",
+		"",
+		0x14);
+}
+
+void KeyVault::LoadSelfISOKeys()
+{
+	sk_ISO_arr.clear();
+	sk_ISO_arr.emplace_back(0x0003003000000000, 0x0001, KEY_ISO,
+		"8860D0CFF4D0DC688D3223321B96B59A777E6914961488E07048DAECB020ECA4",
+		"C82D015D46CF152F1DD0C16F18B5B1E5",
+		"733918D7C888130509346E6B4A8B6CAA357AB557E814E8122BF102C14A314BF9475B9D70EAF9EC29",
+		"009BE892E122A5C943C1BB7403A67318AA9E1B286F",
+		0x36);
+	sk_ISO_arr.emplace_back(0x0003004200000000, 0x0001, KEY_ISO,
+		"101E27F3FA2FB53ACA924F783AD553162D56B975D05B81351A1111799F20254D",
+		"8D2E9C6297B8AD252998458296AC773C",
+		"138446EE0BDDA5638F97328C8956E6489CBBFE57C5961D40DD5C43BB4138F1C400A8B27204A5D625",
+		"00849DBC57D3B92F01864E6E82EB4EF0EF6311E122",
+		0x32);
+	sk_ISO_arr.emplace_back(0x0003005000000000, 0x0001, KEY_ISO,
+		"3F2604FA27AEADFBE1AC69EB00BB16EF196C2193CBD62900FFD8C25041680843",
+		"A414AC1DB7987E43777651B330B899E1",
+		"1F4633AFDE18614D6CEF38A2FD6C4CCAC7B6EB8109D72CD066ECEBA0193EA3F43C37AE83179A4E5F",
+		"0085B4B05DEBA7E6AD831653C974D95149803BB272",
+		0x33);
+	sk_ISO_arr.emplace_back(0x0003005500000000, 0x0001, KEY_ISO,
+		"BDB74AA6E3BA2DC10B1BD7F17198399A158DBE1FA0BEA68C90FCACBE4D04BE37",
+		"0207A479B1574F8E7F697528F05D5435",
+		"917E1F1DC48A54EB5F10B38E7569BB5383628A7C906F0DCA62FDA33805C15FAB270016940A09DB58",
+		"00294411363290975BA551336D3965D88AF029A17B",
+		0x03);
+	sk_ISO_arr.emplace_back(0x0003005600000000, 0x0001, KEY_ISO,
+		"311C015F169F2A1E0757F7064B14C7C9F3A3FFEE015BD4E3A22401A2667857CE",
+		"7BB8B3F5AC8E0890E3148AE5688C7350",
+		"3F040EFA2335FED5670BA4D5C3AB2D9D0B4BA69D154A0062EA995A7D21DBAF0DC5A0DAD333D1C1DD",
+		"",
+		0x08);
+	sk_ISO_arr.emplace_back(0x0003006100000000, 0x0001, KEY_ISO,
+		"8474ADCA3B3244931EECEB9357841442442A1C4A4BCF4E498E6738950F4E4093",
+		"FFF9CACCC4129125CAFB240F419E5F39",
+		"098E1A53E59A95316B00D5A29C05FFEBAE41D1A8A386F9DA96F98858FD25E07BB7A3BC96A5D5B556",
+		"",
+		0x03);
+	sk_ISO_arr.emplace_back(0x0003006600000000, 0x0001, KEY_ISO,
+		"E6A21C599B75696C169EC02582BDA74A776134A6E05108EA701EC0CA2AC03592",
+		"D292A7BD57C0BB2EABBCA1252FA9EDEF",
+		"2ED078A13DC4617EB550AD06E228C83C142A2D588EB5E729402D18038A14842FD65B277DCAD225A5",
+		"",
+		0x08);
+	sk_ISO_arr.emplace_back(0x0003007400000000, 0x0001, KEY_ISO,
+		"072D3A5C3BDB0D674DE209381432B20414BC9BDA0F583ECB94BD9A134176DD51",
+		"8516A81F02CF938740498A406C880871",
+		"5A778DEB5C4F12E8D48E06A2BBBBE3C90FA8C6C47DF9BDB5697FD4A8EB7941CE3F59A557E81C787D",
+		"",
+		0x21);
+	sk_ISO_arr.emplace_back(0x0003007400000000, 0x0100, KEY_ISO,
+		"786FAB8A0B89474A2CB80B3EA104CCCB9E13F66B45EC499BB31865D07C661EA8",
+		"94662F13D99A9F5D211C979FFDF65FE3",
+		"912C94C252B7799CEB45DFBB73EF7CAD9BCC0793A3331BBB79E3C47C0F5C782F698065A8D4DB0D8B",
+		"",
+		0x0E);
+	sk_ISO_arr.emplace_back(0x0004001100000000, 0x0001, KEY_ISO,
+		"4262657A3185D9480F82C8BD2F81766FCC2C8FD7DD5EBE8657B00B939E0C75BD",
+		"4F1E3EF07D893A4714B1B3D5A4E50479",
+		"4DBFCFA68B52F1D66E09AFA6C18EC65479EDBD027B6B8C6A5D85FE5C84D43EA40CEF1672078A0702",
+		"",
+		0x11);
+	sk_ISO_arr.emplace_back(0x0004001100000000, 0x0100, KEY_ISO,
+		"16AA7D7C35399E2B1BFAF68CD19D7512A7855029C08BECC4CC3F035DF7F9C70B",
+		"0E50DB6D937D262CB0499136852FCB80",
+		"AEE2795BF295662A50DFAFE70D1B0B6F0A2EBB211E1323A275FC6E2D13BE4F2F10CA34784F4CF1EC",
+		"",
+		0x0F);
+	sk_ISO_arr.emplace_back(0x0004005000000000, 0x0001, KEY_ISO,
+		"63565DBE98C3B1A52AADC907C47130FE57A10734E84F22592670F86ED2B0A086",
+		"953F6A99891B4739358F5363A00C08B9",
+		"26BE7B02E7D65C6C21BF4063CDB8C0092FE1679D62FA1A8CCC284A1D21885473A959992537A06612",
+		"",
+		0x15);
+	sk_ISO_arr.emplace_back(0x0004005000000000, 0x0100, KEY_ISO,
+		"B96EA32CB96EA32DB96EA32CB96EA32CB96EA32CB96EA32DB96EA32CB96EA32C",
+		"B96EA32CB96EA32DB96EA32DB96EA32C",
+		"2D7066E68C6AC3373B1346FD76FE7D18A207C811500E65D85DB57BC4A27AD78F59FD53F38F50E151",
+		"0044AA25B4276D79B494A29CB8DE104642424F8EEF",
+		0x02);
+}
+
+void KeyVault::LoadSelfAPPKeys()
+{
+	sk_APP_arr.clear();
+	sk_APP_arr.emplace_back(0x0000009200000000, 0x0000, KEY_APP,
+		"95F50019E7A68E341FA72EFDF4D60ED376E25CF46BB48DFDD1F080259DC93F04",
+		"4A0955D946DB70D691A640BB7FAECC4C",
+		"6F8DF8EBD0A1D1DB08B30DD3A951E3F1F27E34030B42C729C55555232D61B834B8BDFFB07E54B343",
+		"006C3E4CCB2C69A5AD7C6F60448E50C7F9184EEAF4",
+		0x21);
+	sk_APP_arr.emplace_back(0x0003003000000000, 0x0001, KEY_APP,
+		"79481839C406A632BDB4AC093D73D99AE1587F24CE7E69192C1CD0010274A8AB",
+		"6F0F25E1C8C4B7AE70DF968B04521DDA",
+		"94D1B7378BAFF5DFED269240A7A364ED68446741622E50BC6079B6E606A2F8E0A4C56E5CFF836526",
+		"003DE80167D2F0E9D30F2145144A558D1174F5410C",
+		0x11);
+	sk_APP_arr.emplace_back(0x0003003000000000, 0x0002, KEY_APP,
+		"4F89BE98DDD43CAD343F5BA6B1A133B0A971566F770484AAC20B5DD1DC9FA06A",
+		"90C127A9B43BA9D8E89FE6529E25206F",
+		"8CA6905F46148D7D8D84D2AFCEAE61B41E6750FC22EA435DFA61FCE6F4F860EE4F54D9196CA5290E",
+		"",
+		0x13);
+	sk_APP_arr.emplace_back(0x0003003000000000, 0x0003, KEY_APP,
+		"C1E6A351FCED6A0636BFCB6801A0942DB7C28BDFC5E0A053A3F52F52FCE9754E",
+		"E0908163F457576440466ACAA443AE7C",
+		"50022D5D37C97905F898E78E7AA14A0B5CAAD5CE8190AE5629A10D6F0CF4173597B37A95A7545C92",
+		"",
+		0x0B);
+	sk_APP_arr.emplace_back(0x0003004200000000, 0x0004, KEY_APP,
+		"838F5860CF97CDAD75B399CA44F4C214CDF951AC795298D71DF3C3B7E93AAEDA",
+		"7FDBB2E924D182BB0D69844ADC4ECA5B",
+		"1F140E8EF887DAB52F079A06E6915A6460B75CD256834A43FA7AF90C23067AF412EDAFE2C1778D69",
+		"0074E922FDEE5DC4CDF22FC8D7986477F813400860",
+		0x14);
+	sk_APP_arr.emplace_back(0x0003004200000000, 0x0005, KEY_APP,
+		"C109AB56593DE5BE8BA190578E7D8109346E86A11088B42C727E2B793FD64BDC",
+		"15D3F191295C94B09B71EBDE088A187A",
+		"B6BB0A84C649A90D97EBA55B555366F52381BB38A84C8BB71DA5A5A0949043C6DB249029A43156F7",
+		"",
+		0x15);
+	sk_APP_arr.emplace_back(0x0003004200000000, 0x0006, KEY_APP,
+		"6DFD7AFB470D2B2C955AB22264B1FF3C67F180983B26C01615DE9F2ECCBE7F41",
+		"24BD1C19D2A8286B8ACE39E4A37801C2",
+		"71F46AC33FF89DF589A100A7FB64CEAC244C9A0CBBC1FDCE80FB4BF8A0D2E66293309CB8EE8CFA95",
+		"",
+		0x2C);
+	sk_APP_arr.emplace_back(0x0003005000000000, 0x0007, KEY_APP,
+		"945B99C0E69CAF0558C588B95FF41B232660ECB017741F3218C12F9DFDEEDE55",
+		"1D5EFBE7C5D34AD60F9FBC46A5977FCE",
+		"AB284CA549B2DE9AA5C903B75652F78D192F8F4A8F3CD99209415C0A84C5C9FD6BF3095C1C18FFCD",
+		"002CF896D35DB871D0E6A252E799876A70D043C23E",
+		0x15);
+	sk_APP_arr.emplace_back(0x0003005000000000, 0x0008, KEY_APP,
+		"2C9E8969EC44DFB6A8771DC7F7FDFBCCAF329EC3EC070900CABB23742A9A6E13",
+		"5A4CEFD5A9C3C093D0B9352376D19405",
+		"6E82F6B54A0E9DEBE4A8B3043EE3B24CD9BBB62B4416B0482582E419A2552E29AB4BEA0A4D7FA2D5",
+		"",
+		0x16);
+	sk_APP_arr.emplace_back(0x0003005000000000, 0x0009, KEY_APP,
+		"F69E4A2934F114D89F386CE766388366CDD210F1D8913E3B973257F1201D632B",
+		"F4D535069301EE888CC2A852DB654461",
+		"1D7B974D10E61C2ED087A0981535904677EC07E96260F89565FF7EBDA4EE035C2AA9BCBDD5893F99",
+		"",
+		0x2D);
+	sk_APP_arr.emplace_back(0x0003005500000000, 0x000A, KEY_APP,
+		"29805302E7C92F204009161CA93F776A072141A8C46A108E571C46D473A176A3",
+		"5D1FAB844107676ABCDFC25EAEBCB633",
+		"09301B6436C85B53CB1585300A3F1AF9FB14DB7C30088C4642AD66D5C148B8995BB1A698A8C71827",
+		"0010818ED8A666051C6198662C3D6DDE2CA4901DDC",
+		0x25);
+	sk_APP_arr.emplace_back(0x0003005500000000, 0x000B, KEY_APP,
+		"A4C97402CC8A71BC7748661FE9CE7DF44DCE95D0D58938A59F47B9E9DBA7BFC3",
+		"E4792F2B9DB30CB8D1596077A13FB3B5",
+		"2733C889D289550FE00EAA5A47A34CEF0C1AF187610EB07BA35D2C09BB73C80B244EB4147700D1BF",
+		"",
+		0x26);
+	sk_APP_arr.emplace_back(0x0003005500000000, 0x000C, KEY_APP,
+		"9814EFFF67B7074D1B263BF85BDC8576CE9DEC914123971B169472A1BC2387FA",
+		"D43B1FA8BE15714B3078C23908BB2BCA",
+		"7D1986C6BEE6CE1E0C5893BD2DF203881F40D5056761CC3F1F2E9D9A378617A2DE40BA5F09844CEB",
+		"",
+		0x3D);
+	sk_APP_arr.emplace_back(0x0003005600000000, 0x000D, KEY_APP,
+		"03B4C421E0C0DE708C0F0B71C24E3EE04306AE7383D8C5621394CCB99FF7A194",
+		"5ADB9EAFE897B54CB1060D6885BE22CF",
+		"71502ADB5783583AB88B2D5F23F419AF01C8B1E72FCA1E694AD49FE3266F1F9C61EFC6F29B351142",
+		"",
+		0x12);
+	sk_APP_arr.emplace_back(0x0003005600000000, 0x000E, KEY_APP,
+		"39A870173C226EB8A3EEE9CA6FB675E82039B2D0CCB22653BFCE4DB013BAEA03",
+		"90266C98CBAA06C1BF145FF760EA1B45",
+		"84DE5692809848E5ACBE25BE548F6981E3DB14735A5DDE1A0FD1F475866532B862B1AB6A004B7255",
+		"",
+		0x27);
+	sk_APP_arr.emplace_back(0x0003005600000000, 0x000F, KEY_APP,
+		"FD52DFA7C6EEF5679628D12E267AA863B9365E6DB95470949CFD235B3FCA0F3B",
+		"64F50296CF8CF49CD7C643572887DA0B",
+		"0696D6CCBD7CF585EF5E00D547503C185D7421581BAD196E081723CD0A97FA40B2C0CD2492B0B5A1",
+		"",
+		0x3A);
+	sk_APP_arr.emplace_back(0x0003006100000000, 0x0010, KEY_APP,
+		"A5E51AD8F32FFBDE808972ACEE46397F2D3FE6BC823C8218EF875EE3A9B0584F",
+		"7A203D5112F799979DF0E1B8B5B52AA4",
+		"50597B7F680DD89F6594D9BDC0CBEE03666AB53647D0487F7F452FE2DD02694631EA755548C9E934",
+		"",
+		0x25);
+	sk_APP_arr.emplace_back(0x0003006100000000, 0x0011, KEY_APP,
+		"0F8EAB8884A51D092D7250597388E3B8B75444AC138B9D36E5C7C5B8C3DF18FD",
+		"97AF39C383E7EF1C98FA447C597EA8FE",
+		"2FDA7A56AAEA65921C0284FF1942C6DE137370093D106034B59191951A5201B422D462F8726F852D",
+		"",
+		0x26);
+	sk_APP_arr.emplace_back(0x0003006600000000, 0x0013, KEY_APP,
+		"DBF62D76FC81C8AC92372A9D631DDC9219F152C59C4B20BFF8F96B64AB065E94",
+		"CB5DD4BE8CF115FFB25801BC6086E729",
+		"B26FE6D3E3A1E766FAE79A8E6A7F48998E7FC1E4B0AD8745FF54C018C2A6CC7A0DD7525FAFEA4917",
+		"",
+		0x12);
+	sk_APP_arr.emplace_back(0x0003006600000000, 0x0014, KEY_APP,
+		"491B0D72BB21ED115950379F4564CE784A4BFAABB00E8CB71294B192B7B9F88E",
+		"F98843588FED8B0E62D7DDCB6F0CECF4",
+		"04275E8838EF95BD013B223C3DF674540932F21B534C7ED2944B9104D938FEB03B824DDB866AB26E",
+		"",
+		0x27);
+	sk_APP_arr.emplace_back(0x0003007400000000, 0x0016, KEY_APP,
+		"A106692224F1E91E1C4EBAD4A25FBFF66B4B13E88D878E8CD072F23CD1C5BF7C",
+		"62773C70BD749269C0AFD1F12E73909E",
+		"566635D3E1DCEC47243AAD1628AE6B2CEB33463FC155E4635846CE33899C5E353DDFA47FEF5694AF",
+		"",
+		0x30);
+	sk_APP_arr.emplace_back(0x0003007400000000, 0x0017, KEY_APP,
+		"4E104DCE09BA878C75DA98D0B1636F0E5F058328D81419E2A3D22AB0256FDF46",
+		"954A86C4629E116532304A740862EF85",
+		"3B7B04C71CAE2B1199D57453C038BB1B541A05AD1B94167B0AB47A9B24CAECB9000CB21407009666",
+		"",
+		0x08);
+	sk_APP_arr.emplace_back(0x0003007400000000, 0x0018, KEY_APP,
+		"1F876AB252DDBCB70E74DC4A20CD8ED51E330E62490E652F862877E8D8D0F997",
+		"BF8D6B1887FA88E6D85C2EDB2FBEC147",
+		"64A04126D77BF6B4D686F6E8F87DD150A5B014BA922D2B694FFF4453E11239A6E0B58F1703C51494",
+		"",
+		0x11);
+	sk_APP_arr.emplace_back(0x0004001100000000, 0x0019, KEY_APP,
+		"3236B9937174DF1DC12EC2DD8A318A0EA4D3ECDEA5DFB4AC1B8278447000C297",
+		"6153DEE781B8ADDC6A439498B816DC46",
+		"148DCA961E2738BAF84B2D1B6E2DA2ABD6A95F2C9571E54C6922F9ED9674F062B7F1BE5BD6FA5268",
+		"",
+		0x31);
+	sk_APP_arr.emplace_back(0x0004001100000000, 0x001A, KEY_APP,
+		"5EFD1E9961462794E3B9EF2A4D0C1F46F642AAE053B5025504130590E66F19C9",
+		"1AC8FA3B3C90F8FDE639515F91B58327",
+		"BE4B1B513536960618BFEF12A713F6673881B02F9DC616191E823FC8337CCF99ADAA6172019C0C23",
+		"",
+		0x17);
+	sk_APP_arr.emplace_back(0x0004001100000000, 0x001B, KEY_APP,
+		"66637570D1DEC098467DB207BAEA786861964D0964D4DBAF89E76F46955D181B",
+		"9F7B5713A5ED59F6B35CD8F8A165D4B8",
+		"4AB6FB1F6F0C3D9219923C1AC683137AB05DF667833CC6A5E8F590E4E28FE2EB180C7D5861117CFB",
+		"",
+		0x12);
+	sk_APP_arr.emplace_back(0x0004004600000000, 0x001C, KEY_APP,
+		"CFF025375BA0079226BE01F4A31F346D79F62CFB643CA910E16CF60BD9092752",
+		"FD40664E2EBBA01BF359B0DCDF543DA4",
+		"36C1ACE6DD5CCC0006FDF3424750FAC515FC5CFA2C93EC53C6EC2BC421708D154E91F2E7EA54A893",
+		"",
+		0x09);
+	sk_APP_arr.emplace_back(0x0004004600000000, 0x001D, KEY_APP,
+		"D202174EB65A62048F3674B59EF6FE72E1872962F3E1CD658DE8D7AF71DA1F3E",
+		"ACB9945914EBB7B9A31ECE320AE09F2D",
+		"430322887503CF52928FAAA410FD623C7321281C8825D95F5B47EF078EFCFC44454C3AB4F00BB879",
+		"",
+		0x1A);
+}
+
+void KeyVault::LoadSelfNPDRMKeys()
+{
+	sk_NPDRM_arr.clear();
+	sk_NPDRM_arr.emplace_back(0x0001000000000000, 0x0001, KEY_NPDRM,
+		"F9EDD0301F770FABBA8863D9897F0FEA6551B09431F61312654E28F43533EA6B",
+		"A551CCB4A42C37A734A2B4F9657D5540",
+		"B05F9DA5F9121EE4031467E74C505C29A8E29D1022379EDFF0500B9AE480B5DAB4578A4C61C5D6BF",
+		"00040AB47509BED04BD96521AD1B365B86BF620A98",
+		0x11);
+	sk_NPDRM_arr.emplace_back(0x0001000000000000, 0x0002, KEY_NPDRM,
+		"8E737230C80E66AD0162EDDD32F1F774EE5E4E187449F19079437A508FCF9C86",
+		"7AAECC60AD12AED90C348D8C11D2BED5",
+		"05BF09CB6FD78050C78DE69CC316FF27C9F1ED66A45BFCE0A1E5A6749B19BD546BBB4602CF373440",
+		"",
+		0x0A);
+	sk_NPDRM_arr.emplace_back(0x0003003000000000, 0x0003, KEY_NPDRM,
+		"1B715B0C3E8DC4C1A5772EBA9C5D34F7CCFE5B82025D453F3167566497239664",
+		"E31E206FBB8AEA27FAB0D9A2FFB6B62F",
+		"3F51E59FC74D6618D34431FA67987FA11ABBFACC7111811473CD9988FE91C43FC74605E7B8CB732D",
+		"",
+		0x08);
+	sk_NPDRM_arr.emplace_back(0x0003004200000000, 0x0004, KEY_NPDRM,
+		"BB4DBF66B744A33934172D9F8379A7A5EA74CB0F559BB95D0E7AECE91702B706",
+		"ADF7B207A15AC601110E61DDFC210AF6",
+		"9C327471BAFF1F877AE4FE29F4501AF5AD6A2C459F8622697F583EFCA2CA30ABB5CD45D1131CAB30",
+		"00B61A91DF4AB6A9F142C326BA9592B5265DA88856",
+		0x16);
+	sk_NPDRM_arr.emplace_back(0x0003004200000000, 0x0006, KEY_NPDRM,
+		"8B4C52849765D2B5FA3D5628AFB17644D52B9FFEE235B4C0DB72A62867EAA020",
+		"05719DF1B1D0306C03910ADDCE4AF887",
+		"2A5D6C6908CA98FC4740D834C6400E6D6AD74CF0A712CF1E7DAE806E98605CC308F6A03658F2970E",
+		"",
+		0x29);
+	sk_NPDRM_arr.emplace_back(0x0003005000000000, 0x0007, KEY_NPDRM,
+		"3946DFAA141718C7BE339A0D6C26301C76B568AEBC5CD52652F2E2E0297437C3",
+		"E4897BE553AE025CDCBF2B15D1C9234E",
+		"A13AFE8B63F897DA2D3DC3987B39389DC10BAD99DFB703838C4A0BC4E8BB44659C726CFD0CE60D0E",
+		"009EF86907782A318D4CC3617EBACE2480E73A46F6",
+		0x17);
+	sk_NPDRM_arr.emplace_back(0x0003005000000000, 0x0009, KEY_NPDRM,
+		"0786F4B0CA5937F515BDCE188F569B2EF3109A4DA0780A7AA07BD89C3350810A",
+		"04AD3C2F122A3B35E804850CAD142C6D",
+		"A1FE61035DBBEA5A94D120D03C000D3B2F084B9F4AFA99A2D4A588DF92B8F36327CE9E47889A45D0",
+		"",
+		0x2A);
+	sk_NPDRM_arr.emplace_back(0x0003005500000000, 0x000A, KEY_NPDRM,
+		"03C21AD78FBB6A3D425E9AAB1298F9FD70E29FD4E6E3A3C151205DA50C413DE4",
+		"0A99D4D4F8301A88052D714AD2FB565E",
+		"3995C390C9F7FBBAB124A1C14E70F9741A5E6BDF17A605D88239652C8EA7D5FC9F24B30546C1E44B",
+		"009AC6B22A056BA9E0B6D1520F28A57A3135483F9F",
+		0x27);
+	sk_NPDRM_arr.emplace_back(0x0003005500000000, 0x000C, KEY_NPDRM,
+		"357EBBEA265FAEC271182D571C6CD2F62CFA04D325588F213DB6B2E0ED166D92",
+		"D26E6DD2B74CD78E866E742E5571B84F",
+		"00DCF5391618604AB42C8CFF3DC304DF45341EBA4551293E9E2B68FFE2DF527FFA3BE8329E015E57",
+		"",
+		0x3A);
+	sk_NPDRM_arr.emplace_back(0x0003005600000000, 0x000D, KEY_NPDRM,
+		"337A51416105B56E40D7CAF1B954CDAF4E7645F28379904F35F27E81CA7B6957",
+		"8405C88E042280DBD794EC7E22B74002",
+		"9BFF1CC7118D2393DE50D5CF44909860683411A532767BFDAC78622DB9E5456753FE422CBAFA1DA1",
+		"",
+		0x18);
+	sk_NPDRM_arr.emplace_back(0x0003005600000000, 0x000F, KEY_NPDRM,
+		"135C098CBE6A3E037EBE9F2BB9B30218DDE8D68217346F9AD33203352FBB3291",
+		"4070C898C2EAAD1634A288AA547A35A8",
+		"BBD7CCCB556C2EF0F908DC7810FAFC37F2E56B3DAA5F7FAF53A4944AA9B841F76AB091E16B231433",
+		"",
+		0x3B);
+	sk_NPDRM_arr.emplace_back(0x0003006100000000, 0x0010, KEY_NPDRM,
+		"4B3CD10F6A6AA7D99F9B3A660C35ADE08EF01C2C336B9E46D1BB5678B4261A61",
+		"C0F2AB86E6E0457552DB50D7219371C5",
+		"64A5C60BC2AD18B8A237E4AA690647E12BF7A081523FAD4F29BE89ACAC72F7AB43C74EC9AFFDA213",
+		"",
+		0x27);
+	sk_NPDRM_arr.emplace_back(0x0003006600000000, 0x0013, KEY_NPDRM,
+		"265C93CF48562EC5D18773BEB7689B8AD10C5EB6D21421455DEBC4FB128CBF46",
+		"8DEA5FF959682A9B98B688CEA1EF4A1D",
+		"9D8DB5A880608DC69717991AFC3AD5C0215A5EE413328C2ABC8F35589E04432373DB2E2339EEF7C8",
+		"",
+		0x18);
+	sk_NPDRM_arr.emplace_back(0x0003007400000000, 0x0016, KEY_NPDRM,
+		"7910340483E419E55F0D33E4EA5410EEEC3AF47814667ECA2AA9D75602B14D4B",
+		"4AD981431B98DFD39B6388EDAD742A8E",
+		"62DFE488E410B1B6B2F559E4CB932BCB78845AB623CC59FDF65168400FD76FA82ED1DC60E091D1D1",
+		"",
+		0x25);
+	sk_NPDRM_arr.emplace_back(0x0004001100000000, 0x0019, KEY_NPDRM,
+		"FBDA75963FE690CFF35B7AA7B408CF631744EDEF5F7931A04D58FD6A921FFDB3",
+		"F72C1D80FFDA2E3BF085F4133E6D2805",
+		"637EAD34E7B85C723C627E68ABDD0419914EBED4008311731DD87FDDA2DAF71F856A70E14DA17B42",
+		"",
+		0x24);
+	sk_NPDRM_arr.emplace_back(0x0004004600000000, 0x001C, KEY_NPDRM,
+		"8103EA9DB790578219C4CEDF0592B43064A7D98B601B6C7BC45108C4047AA80F",
+		"246F4B8328BE6A2D394EDE20479247C5",
+		"503172C9551308A87621ECEE90362D14889BFED2CF32B0B3E32A4F9FE527A41464B735E1ADBC6762",
+		"",
+		0x30);
+}
+
+void KeyVault::LoadSelfUNK7Keys()
+{
+	sk_UNK7_arr.clear();
+	sk_UNK7_arr.emplace_back(0x0003003000000000, 0x0000, KEY_UNK7,
+		"D91166973979EA8694476B011AC62C7E9F37DA26DE1E5C2EE3D66E42B8517085",
+		"DC01280A6E46BC674B81A7E8801EBE6E",
+		"A0FC44108236141BF3517A662B027AFC1AC513A05690496C754DEB7D43BDC41B80FD75C212624EE4",
+		"",
+		0x11);
+	sk_UNK7_arr.emplace_back(0x0003004200000000, 0x0000, KEY_UNK7,
+		"B73111B0B00117E48DE5E2EE5E534C0F0EFFA4890BBB8CAD01EE0F848F91583E",
+		"86F56F9E5DE513894874B8BA253334B1",
+		"B0BA1A1AB9723BB4E87CED9637BE056066BC56E16572D43D0210A06411DBF8FEB8885CD912384AE5",
+		"",
+		0x12);
+	sk_UNK7_arr.emplace_back(0x0003005000000000, 0x0000, KEY_UNK7,
+		"8E944267C02E69A4FE474B7F5FCD7974A4F936FF4355AEC4F80EFA123858D8F6",
+		"908A75754E521EAC2F5A4889C6D7B72D",
+		"91201DA7D79E8EE2563142ECBD646DA026C963AC09E760E5390FFE24DAE6864310ABE147F8204D0B",
+		"",
+		0x13);
+	sk_UNK7_arr.emplace_back(0x0003005500000000, 0x0000, KEY_UNK7,
+		"BB31DF9A6F62C0DF853075FAA65134D9CE2240306C1731D1F7DA9B5329BD699F",
+		"263057225873F83940A65C8C926AC3E4",
+		"BC3A82A4F44C43A197070CD236FDC94FCC542D69A3E803E0AFF78D1F3DA19A79D2F61FAB5B94B437",
+		"",
+		0x23);
+	sk_UNK7_arr.emplace_back(0x0003005600000000, 0x0000, KEY_UNK7,
+		"71AA75C70A255580E4AE9BDAA0B08828C53EAA713CD0713797F143B284C1589B",
+		"9DED878CB6BA07121C0F50E7B172A8BF",
+		"387FCDAEAFF1B59CFAF79CE6215A065ACEAFFAF4048A4F217E1FF5CE67C66EC3F089DB235E52F9D3",
+		"",
+		0x29);
+	sk_UNK7_arr.emplace_back(0x0003006100000000, 0x0000, KEY_UNK7,
+		"F5D1DBC182F5083CD4EA37C431C7DAC73882C07F232D2699B1DD9FDDF1BF4195",
+		"D3A7C3C91CBA014FCBCA6D5570DE13FF",
+		"97CA8A9781F45E557E98F176EF794FCDA6B151EB3DFD1ABA12151E00AE59957C3B15628FC8875D28",
+		"",
+		0x23);
+	sk_UNK7_arr.emplace_back(0x0003006600000000, 0x0000, KEY_UNK7,
+		"BF10F09590C0152F7EF749FF4B990122A4E8E5491DA49A2D931E72EEB990F860",
+		"22C19C5522F7A782AFC547C2640F5BDE",
+		"3233BA2B284189FB1687DF653002257A0925D8EB0C64EBBE8CC7DE87F548D107DE1FD3D1D285DB4F",
+		"",
+		0x29);
+	sk_UNK7_arr.emplace_back(0x0003007400000000, 0x0000, KEY_UNK7,
+		"F11DBD2C97B32AD37E55F8E743BC821D3E67630A6784D9A058DDD26313482F0F",
+		"FC5FA12CA3D2D336C4B8B425D679DA55",
+		"19E27EE90E33EDAB16B22E688B5F704E5C6EC1062070EBF43554CD03DFDAE16D684BB8B5574DBECA",
+		"",
+		0x15);
+	sk_UNK7_arr.emplace_back(0x0004001100000000, 0x0000, KEY_UNK7,
+		"751EE949CD3ADF50A469197494A1EC358409CCBE6E85217EBDE7A87D3FF1ABD8",
+		"23AE4ADA4D3F798DC5ED98000337FF77",
+		"1BABA87CD1AD705C462D4E7427B6DAF59A50383A348A15088F0EDFCF1ADF2B5C2B2D507B2A357D36",
+		"",
+		0x1A);
+	sk_UNK7_arr.emplace_back(0x0004004600000000, 0x0000, KEY_UNK7,
+		"46BD0891224E0CE13E2162921D4BB76193AEEE4416A729FCDD111C5536BF87C9",
+		"BF036387CDB613C0AC88A6D9D2CC5316",
+		"A14F6D5F9AD7EBB3B7A39A7C32F13E5DC3B0BA16BDC33D39FDDF88F4AEEA6CFEEB0C0796C917A952",
+		"",
+		0x0F);
+}
+
+SELF_KEY KeyVault::GetSelfLV0Key()
+{
+	return sk_LV0_arr[0];
+}
+
+SELF_KEY KeyVault::GetSelfLDRKey()
+{
+	return sk_LDR_arr[0];
+}
+
+SELF_KEY KeyVault::GetSelfLV1Key(u64 version)
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_LV1_arr.size(); i++)
+	{
+		if (sk_LV1_arr[i].version == version)
+		{
+			key = sk_LV1_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfLV2Key(u64 version)
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_LV2_arr.size(); i++)
+	{
+		if (sk_LV2_arr[i].version == version)
+		{
+			key = sk_LV2_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfISOKey(u16 revision, u64 version)
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_ISO_arr.size(); i++)
+	{
+		if ((sk_ISO_arr[i].version == version) &&
+			(sk_ISO_arr[i].revision == revision))
+		{
+			key = sk_ISO_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfAPPKey(u16 revision)
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_APP_arr.size(); i++)
+	{
+		if (sk_APP_arr[i].revision == revision)
+		{
+			key = sk_APP_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfUNK7Key(u64 version)
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_UNK7_arr.size(); i++)
+	{
+		if (sk_UNK7_arr[i].version == version)
+		{
+			key = sk_UNK7_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfNPDRMKey(u16 revision)
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_NPDRM_arr.size(); i++)
+	{
+		if (sk_NPDRM_arr[i].revision == revision)
+		{
+			key = sk_NPDRM_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::FindSelfKey(u32 type, u16 revision, u64 version)
+{
+	// Empty key.
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	// Check SELF type.
+	switch (type)
+	{
+	case KEY_LV0:
+		LoadSelfLV0Keys();
+		key = GetSelfLV0Key();
+		break;
+	case KEY_LV1:
+		LoadSelfLV1Keys();
+		key = GetSelfLV1Key(version);
+		break;
+	case KEY_LV2:
+		LoadSelfLV2Keys();
+		key = GetSelfLV2Key(version);
+		break;
+	case KEY_APP:
+		LoadSelfAPPKeys();
+		key = GetSelfAPPKey(revision);
+		break;
+	case KEY_ISO:
+		LoadSelfISOKeys();
+		key = GetSelfISOKey(revision, version);
+		break;
+	case KEY_LDR:
+		LoadSelfLDRKeys();
+		key = GetSelfLDRKey();
+		break;
+	case KEY_UNK7:
+		LoadSelfUNK7Keys();
+		key = GetSelfUNK7Key(version);
+		break;
+	case KEY_NPDRM:
+		LoadSelfNPDRMKeys();
+		key = GetSelfNPDRMKey(revision);
+		break;
+	default:
+		break;
+	}
+
+	return key;
+}
+
+void KeyVault::SetKlicenseeKey(u8 *key)
+{
+	memcpy(klicensee_key, key, 0x10);
+}
+
+u8 *KeyVault::GetKlicenseeKey()
+{
+	return klicensee_key;
+}
 
 void rap_to_rif(unsigned char* rap, unsigned char* rif)
 {
@@ -844,7 +755,7 @@ void rap_to_rif(unsigned char* rap, unsigned char* rif)
 	memset(iv, 0, 0x10);
 
 	// Initial decrypt.
-	aes_setkey_dec(&aes, RAP_KEY, 128);
+	aes_setkey_dec(&aes, RAP_KEY, 128);
 	aes_crypt_cbc(&aes, AES_DECRYPT, 0x10, iv, rap, key);
 
 	// rap2rifkey round.
@@ -875,4 +786,5 @@ void rap_to_rif(unsigned char* rap, unsigned char* rif)
 	}
 
 	memcpy(rif, key, 0x10);
-}
\ No newline at end of file
+}
+
diff --git a/rpcs3/Crypto/key_vault.h b/rpcs3/Crypto/key_vault.h
index 411c592fe5..3f78228e9e 100644
--- a/rpcs3/Crypto/key_vault.h
+++ b/rpcs3/Crypto/key_vault.h
@@ -1,6 +1,6 @@
-#pragma once
-#include "utils.h"
-
+#pragma once
+#include "utils.h"
+
 enum SELF_KEY_TYPE {
 	KEY_LV0 = 1,
 	KEY_LV1,
@@ -22,7 +22,7 @@ struct SELF_KEY {
 	u8 priv[0x15];
 	u32 curve_type;
 
-	SELF_KEY(u64 ver, u16 rev, u32 type, const std::string& e, const std::string& r, const std::string& pb, const std::string& pr, u32 ct)
+	SELF_KEY(u64 ver, u16 rev, u32 type, const std::string& e, const std::string& r, const std::string& pb, const std::string& pr, u32 ct)
 	{
 		version = ver;
 		revision = rev;
@@ -35,12 +35,12 @@ struct SELF_KEY {
 	}
 };
 
-static u8 PKG_AES_KEY[0x10] = {
-	0x2e, 0x7b, 0x71, 0xd7, 0xc9, 0xc9, 0xa1, 0x4e, 0xa3, 0x22, 0x1f, 0x18, 0x88, 0x28, 0xb8, 0xf8
+static u8 PKG_AES_KEY[0x10] = {
+	0x2e, 0x7b, 0x71, 0xd7, 0xc9, 0xc9, 0xa1, 0x4e, 0xa3, 0x22, 0x1f, 0x18, 0x88, 0x28, 0xb8, 0xf8
 };
 
-static u8 NP_IDPS[0x10] = {
-	0x5E, 0x06, 0xE0, 0x4F, 0xD9, 0x4A, 0x71, 0xBF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+static u8 NP_IDPS[0x10] = {
+	0x5E, 0x06, 0xE0, 0x4F, 0xD9, 0x4A, 0x71, 0xBF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
 };
 
 static u8 NP_KLIC_FREE[0x10] = {
@@ -114,43 +114,43 @@ static u8 EDAT_HASH_1[0x10] = {
 static u8 EDAT_IV[0x10] = {
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
-
-class KeyVault
-{
-	Array<SELF_KEY> sk_LV0_arr;
-	Array<SELF_KEY> sk_LV1_arr;
-	Array<SELF_KEY> sk_LV2_arr;
-	Array<SELF_KEY> sk_APP_arr;
-	Array<SELF_KEY> sk_ISO_arr;
-	Array<SELF_KEY> sk_LDR_arr;
-	Array<SELF_KEY> sk_UNK7_arr;
-	Array<SELF_KEY> sk_NPDRM_arr;
-	u8 klicensee_key[0x10];
-
-public:
-	KeyVault();
-	SELF_KEY FindSelfKey(u32 type, u16 revision, u64 version);
-	void SetKlicenseeKey(u8 *key);
-	u8 *GetKlicenseeKey();
-
-private:	
-	void LoadSelfLV0Keys();
-	void LoadSelfLDRKeys();
-	void LoadSelfLV1Keys();
-	void LoadSelfLV2Keys();
-	void LoadSelfISOKeys();
-	void LoadSelfAPPKeys();
-	void LoadSelfUNK7Keys();
-	void LoadSelfNPDRMKeys();
-	SELF_KEY GetSelfLV0Key();
-	SELF_KEY GetSelfLDRKey();
-	SELF_KEY GetSelfLV1Key(u64 version);
-	SELF_KEY GetSelfLV2Key(u64 version);
-	SELF_KEY GetSelfISOKey(u16 revision, u64 version);
-	SELF_KEY GetSelfAPPKey(u16 revision);
-	SELF_KEY GetSelfUNK7Key(u64 version);
-	SELF_KEY GetSelfNPDRMKey(u16 revision);
-};
-
+
+class KeyVault
+{
+	std::vector<SELF_KEY> sk_LV0_arr;
+	std::vector<SELF_KEY> sk_LV1_arr;
+	std::vector<SELF_KEY> sk_LV2_arr;
+	std::vector<SELF_KEY> sk_APP_arr;
+	std::vector<SELF_KEY> sk_ISO_arr;
+	std::vector<SELF_KEY> sk_LDR_arr;
+	std::vector<SELF_KEY> sk_UNK7_arr;
+	std::vector<SELF_KEY> sk_NPDRM_arr;
+	u8 klicensee_key[0x10];
+
+public:
+	KeyVault();
+	SELF_KEY FindSelfKey(u32 type, u16 revision, u64 version);
+	void SetKlicenseeKey(u8 *key);
+	u8 *GetKlicenseeKey();
+
+private:	
+	void LoadSelfLV0Keys();
+	void LoadSelfLDRKeys();
+	void LoadSelfLV1Keys();
+	void LoadSelfLV2Keys();
+	void LoadSelfISOKeys();
+	void LoadSelfAPPKeys();
+	void LoadSelfUNK7Keys();
+	void LoadSelfNPDRMKeys();
+	SELF_KEY GetSelfLV0Key();
+	SELF_KEY GetSelfLDRKey();
+	SELF_KEY GetSelfLV1Key(u64 version);
+	SELF_KEY GetSelfLV2Key(u64 version);
+	SELF_KEY GetSelfISOKey(u16 revision, u64 version);
+	SELF_KEY GetSelfAPPKey(u16 revision);
+	SELF_KEY GetSelfUNK7Key(u64 version);
+	SELF_KEY GetSelfNPDRMKey(u16 revision);
+};
+
 // RAP to RIF function.
-void rap_to_rif(unsigned char* rap, unsigned char* rif);
\ No newline at end of file
+void rap_to_rif(unsigned char* rap, unsigned char* rif);
diff --git a/rpcs3/Crypto/unself.cpp b/rpcs3/Crypto/unself.cpp
index 72a38fa8fa..df8d0838ae 100644
--- a/rpcs3/Crypto/unself.cpp
+++ b/rpcs3/Crypto/unself.cpp
@@ -36,7 +36,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 	// Read ELF program headers.
 	if (isElf32)
 	{
-		phdr32_arr.Clear();
+		phdr32_arr.clear();
 		if(elf32_hdr.e_phoff == 0 && elf32_hdr.e_phnum)
 		{
 			ConLog.Error("SELF: ELF program header offset is null!");
@@ -45,14 +45,13 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 		self_f.Seek(self_hdr.se_phdroff);
 		for(u32 i = 0; i < elf32_hdr.e_phnum; ++i)
 		{
-			Elf32_Phdr* phdr = new Elf32_Phdr();
-			phdr->Load(self_f);
-			phdr32_arr.Move(phdr);
+			phdr32_arr.emplace_back();
+			phdr32_arr.back().Load(self_f);
 		}
 	}
 	else
 	{
-		phdr64_arr.Clear();
+		phdr64_arr.clear();
 		if(elf64_hdr.e_phoff == 0 && elf64_hdr.e_phnum)
 		{
 			ConLog.Error("SELF: ELF program header offset is null!");
@@ -61,22 +60,20 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 		self_f.Seek(self_hdr.se_phdroff);
 		for(u32 i = 0; i < elf64_hdr.e_phnum; ++i)
 		{
-			Elf64_Phdr* phdr = new Elf64_Phdr();
-			phdr->Load(self_f);
-			phdr64_arr.Move(phdr);
+			phdr64_arr.emplace_back();
+			phdr64_arr.back().Load(self_f);
 		}
 	}
 
 
 	// Read section info.
-	secinfo_arr.Clear();
+	secinfo_arr.clear();
 	self_f.Seek(self_hdr.se_secinfoff);
 
 	for(u32 i = 0; i < ((isElf32) ? elf32_hdr.e_phnum : elf64_hdr.e_phnum); ++i)
 	{
-		SectionInfo* sinfo = new SectionInfo();
-		sinfo->Load(self_f);
-		secinfo_arr.Move(sinfo);
+		secinfo_arr.emplace_back();
+		secinfo_arr.back().Load(self_f);
 	}
 
 	// Read SCE version info.
@@ -84,22 +81,22 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 	scev_info.Load(self_f);
 
 	// Read control info.
-	ctrlinfo_arr.Clear();
+	ctrlinfo_arr.clear();
 	self_f.Seek(self_hdr.se_controloff);
 
 	u32 i = 0;
 	while(i < self_hdr.se_controlsize)
 	{
-		ControlInfo* cinfo = new ControlInfo();
-		cinfo->Load(self_f);
-		i += cinfo->size;
-		ctrlinfo_arr.Move(cinfo);
+		ctrlinfo_arr.emplace_back();
+		ControlInfo &cinfo = ctrlinfo_arr.back();
+		cinfo.Load(self_f);
+		i += cinfo.size;
 	}
 
 	// Read ELF section headers.
 	if (isElf32)
 	{
-		shdr32_arr.Clear();
+		shdr32_arr.clear();
 		if(elf32_hdr.e_shoff == 0 && elf32_hdr.e_shnum)
 		{
 			ConLog.Warning("SELF: ELF section header offset is null!");
@@ -108,14 +105,13 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 		self_f.Seek(self_hdr.se_shdroff);
 		for(u32 i = 0; i < elf32_hdr.e_shnum; ++i)
 		{
-			Elf32_Shdr* shdr = new Elf32_Shdr();
-			shdr->Load(self_f);
-			shdr32_arr.Move(shdr);
+			shdr32_arr.emplace_back();
+			shdr32_arr.back().Load(self_f);
 		}
 	}
 	else
 	{
-		shdr64_arr.Clear();
+		shdr64_arr.clear();
 		if(elf64_hdr.e_shoff == 0 && elf64_hdr.e_shnum)
 		{
 			ConLog.Warning("SELF: ELF section header offset is null!");
@@ -124,9 +120,8 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 		self_f.Seek(self_hdr.se_shdroff);
 		for(u32 i = 0; i < elf64_hdr.e_shnum; ++i)
 		{
-			Elf64_Shdr* shdr = new Elf64_Shdr();
-			shdr->Load(self_f);
-			shdr64_arr.Move(shdr);
+			shdr64_arr.emplace_back();
+			shdr64_arr.back().Load(self_f);
 		}
 	}
 
@@ -153,12 +148,12 @@ void SELFDecrypter::ShowHeaders(bool isElf32)
 	ConLog.Write("----------------------------------------------------");
 	ConLog.Write("ELF program headers");
 	ConLog.Write("----------------------------------------------------");
-	for(unsigned int i = 0; i < ((isElf32) ? phdr32_arr.GetCount() : phdr64_arr.GetCount()); i++)
+	for(unsigned int i = 0; i < ((isElf32) ? phdr32_arr.size() : phdr64_arr.size()); i++)
 		isElf32 ? phdr32_arr[i].Show() : phdr64_arr[i].Show();
 	ConLog.Write("----------------------------------------------------");
 	ConLog.Write("Section info");
 	ConLog.Write("----------------------------------------------------");
-	for(unsigned int i = 0; i < secinfo_arr.GetCount(); i++)
+	for(unsigned int i = 0; i < secinfo_arr.size(); i++)
 		secinfo_arr[i].Show();
 	ConLog.Write("----------------------------------------------------");
 	ConLog.Write("SCE version info");
@@ -167,12 +162,12 @@ void SELFDecrypter::ShowHeaders(bool isElf32)
 	ConLog.Write("----------------------------------------------------");
 	ConLog.Write("Control info");
 	ConLog.Write("----------------------------------------------------");
-	for(unsigned int i = 0; i < ctrlinfo_arr.GetCount(); i++)
+	for(unsigned int i = 0; i < ctrlinfo_arr.size(); i++)
 		ctrlinfo_arr[i].Show();
 	ConLog.Write("----------------------------------------------------");
 	ConLog.Write("ELF section headers");
 	ConLog.Write("----------------------------------------------------");
-	for(unsigned int i = 0; i < ((isElf32) ? shdr32_arr.GetCount() : shdr64_arr.GetCount()); i++)
+	for(unsigned int i = 0; i < ((isElf32) ? shdr32_arr.size() : shdr64_arr.size()); i++)
 		isElf32 ? shdr32_arr[i].Show() : shdr64_arr[i].Show();
 	ConLog.Write("----------------------------------------------------");
 }
@@ -185,7 +180,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
 	u8 npdrm_iv[0x10];
 
 	// Parse the control info structures to find the NPDRM control info.
-	for(unsigned int i = 0; i < ctrlinfo_arr.GetCount(); i++)
+	for(unsigned int i = 0; i < ctrlinfo_arr.size(); i++)
 	{
 		if (ctrlinfo_arr[i].type == 3)
 		{
@@ -307,12 +302,11 @@ bool SELFDecrypter::LoadMetadata()
 	meta_hdr.Load(metadata_headers);
 
 	// Load the metadata section headers.
-	meta_shdr.Clear();
+	meta_shdr.clear();
 	for (unsigned int i = 0; i < meta_hdr.section_count; i++)
 	{
-		MetadataSectionHeader* m_shdr = new MetadataSectionHeader();
-		m_shdr->Load(metadata_headers + sizeof(meta_hdr) + sizeof(MetadataSectionHeader) * i);
-		meta_shdr.Move(m_shdr);
+		meta_shdr.emplace_back();
+		meta_shdr.back().Load(metadata_headers + sizeof(meta_hdr) + sizeof(MetadataSectionHeader) * i);
 	}
 
 	// Copy the decrypted data keys.
diff --git a/rpcs3/Crypto/unself.h b/rpcs3/Crypto/unself.h
index 9d16fc2d6a..bd72125eac 100644
--- a/rpcs3/Crypto/unself.h
+++ b/rpcs3/Crypto/unself.h
@@ -1,11 +1,11 @@
-#pragma once
-#include "utils.h"
-#include "key_vault.h"
-#include "Loader/ELF.h"
-#include "Loader/SELF.h"
-#include <wx/mstream.h>
-#include <wx/zstream.h>
-
+#pragma once
+#include "utils.h"
+#include "key_vault.h"
+#include "Loader/ELF.h"
+#include "Loader/SELF.h"
+#include <wx/mstream.h>
+#include <wx/zstream.h>
+
 struct AppInfo 
 {
   u64 authid;
@@ -14,20 +14,20 @@ struct AppInfo
   u64 version;
   u64 padding;
 
-  void Load(vfsStream& f)
-  {
-		authid		= Read64(f);
-		vendor_id	= Read32(f);
-		self_type	= Read32(f);
-		version		= Read64(f);
+  void Load(vfsStream& f)
+  {
+		authid		= Read64(f);
+		vendor_id	= Read32(f);
+		self_type	= Read32(f);
+		version		= Read64(f);
 		padding		= Read64(f);
   }
 
-  void Show()
-  {
-	  ConLog.Write("AuthID: 0x%llx",			authid);
-	  ConLog.Write("VendorID: 0x%08x",			vendor_id);
-	  ConLog.Write("SELF type: 0x%08x",			self_type);
+  void Show()
+  {
+	  ConLog.Write("AuthID: 0x%llx",			authid);
+	  ConLog.Write("VendorID: 0x%08x",			vendor_id);
+	  ConLog.Write("SELF type: 0x%08x",			self_type);
 	  ConLog.Write("Version: 0x%llx",		    version);
   }
 };
@@ -41,21 +41,21 @@ struct SectionInfo
   u32 unknown2;
   u32 encrypted;
 
-  void Load(vfsStream& f)
-  {
-		offset			= Read64(f);
-		size			= Read64(f);
-		compressed		= Read32(f);
-		unknown1		= Read32(f);
+  void Load(vfsStream& f)
+  {
+		offset			= Read64(f);
+		size			= Read64(f);
+		compressed		= Read32(f);
+		unknown1		= Read32(f);
 		unknown2		= Read32(f);
 		encrypted		= Read32(f);
   }
 
-  void Show()
-  {
-	  ConLog.Write("Offset: 0x%llx",			offset);
-	  ConLog.Write("Size: 0x%llx",				size);
-	  ConLog.Write("Compressed: 0x%08x",		compressed);
+  void Show()
+  {
+	  ConLog.Write("Offset: 0x%llx",			offset);
+	  ConLog.Write("Size: 0x%llx",				size);
+	  ConLog.Write("Compressed: 0x%08x",		compressed);
 	  ConLog.Write("Unknown1: 0x%08x",			unknown1);
 	  ConLog.Write("Unknown2: 0x%08x",			unknown2);
 	  ConLog.Write("Encrypted: 0x%08x",			encrypted);
@@ -69,19 +69,19 @@ struct SCEVersionInfo
   u32 size;
   u32 unknown;
 
-  void Load(vfsStream& f)
-  {
-	  subheader_type	= Read32(f);
-	  present			= Read32(f);
-	  size				= Read32(f);
+  void Load(vfsStream& f)
+  {
+	  subheader_type	= Read32(f);
+	  present			= Read32(f);
+	  size				= Read32(f);
 	  unknown			= Read32(f);
   }
 
-  void Show()
-  {
-	  ConLog.Write("Sub-header type: 0x%08x",			subheader_type);
-	  ConLog.Write("Present: 0x%08x",					present);
-	  ConLog.Write("Size: 0x%08x",						size);
+  void Show()
+  {
+	  ConLog.Write("Sub-header type: 0x%08x",			subheader_type);
+	  ConLog.Write("Present: 0x%08x",					present);
+	  ConLog.Write("Size: 0x%08x",						size);
 	  ConLog.Write("Unknown: 0x%08x",					unknown);
   }
 };
@@ -133,9 +133,9 @@ struct ControlInfo
     } npdrm;
   };
 
-  void Load(vfsStream& f)
-  {
-	  type							= Read32(f);
+  void Load(vfsStream& f)
+  {
+	  type							= Read32(f);
 	  size							= Read32(f);
 	  next							= Read64(f);
 
@@ -179,10 +179,10 @@ struct ControlInfo
 	  }
   }
 
-  void Show()
-  {
-	  ConLog.Write("Type: 0x%08x",			type);
-	  ConLog.Write("Size: 0x%08x",			size);
+  void Show()
+  {
+	  ConLog.Write("Type: 0x%08x",			type);
+	  ConLog.Write("Size: 0x%08x",			size);
 	  ConLog.Write("Next: 0x%llx",			next);
 
 	  if (type == 1)
@@ -259,11 +259,11 @@ struct MetadataInfo
   u8 iv[0x10];
   u8 iv_pad[0x10];
 
-  void Load(u8* in)
-  {
-	  memcpy(key, in, 0x10);
-	  memcpy(key_pad, in + 0x10, 0x10);
-	  memcpy(iv, in + 0x20, 0x10);
+  void Load(u8* in)
+  {
+	  memcpy(key, in, 0x10);
+	  memcpy(key_pad, in + 0x10, 0x10);
+	  memcpy(iv, in + 0x20, 0x10);
 	  memcpy(iv_pad, in + 0x30, 0x10);
   }
 
@@ -298,11 +298,11 @@ struct MetadataHeader
   u32 unknown2;
   u32 unknown3;
 
-  void Load(u8* in)
-  {
-	  memcpy(&signature_input_length, in, 8);
-	  memcpy(&unknown1, in + 8, 4);
-	  memcpy(&section_count, in + 12, 4);
+  void Load(u8* in)
+  {
+	  memcpy(&signature_input_length, in, 8);
+	  memcpy(&unknown1, in + 8, 4);
+	  memcpy(&section_count, in + 12, 4);
 	  memcpy(&key_count, in + 16, 4);
 	  memcpy(&opt_header_size, in + 20, 4);
 	  memcpy(&unknown2, in + 24, 4);
@@ -318,11 +318,11 @@ struct MetadataHeader
 	  unknown3 = swap32(unknown3);
   }
 
-  void Show()
-  {
-	  ConLog.Write("Signature input length: 0x%llx",			signature_input_length);
-	  ConLog.Write("Unknown1: 0x%08x",							unknown1);
-	  ConLog.Write("Section count: 0x%08x",						section_count);
+  void Show()
+  {
+	  ConLog.Write("Signature input length: 0x%llx",			signature_input_length);
+	  ConLog.Write("Unknown1: 0x%08x",							unknown1);
+	  ConLog.Write("Section count: 0x%08x",						section_count);
 	  ConLog.Write("Key count: 0x%08x",							key_count);
 	  ConLog.Write("Optional header size: 0x%08x",				opt_header_size);
 	  ConLog.Write("Unknown2: 0x%08x",							unknown2);
@@ -343,17 +343,17 @@ struct MetadataSectionHeader
   u32 iv_idx;
   u32 compressed;
 
-  void Load(u8* in)
-  {
-	  memcpy(&data_offset, in, 8);
-	  memcpy(&data_size, in + 8, 8);
-	  memcpy(&type, in + 16, 4);
-	  memcpy(&program_idx, in + 20, 4);
-	  memcpy(&hashed, in + 24, 4);
-	  memcpy(&sha1_idx, in + 28, 4);
-	  memcpy(&encrypted, in + 32, 4);
-	  memcpy(&key_idx, in + 36, 4);
-	  memcpy(&iv_idx, in + 40, 4);
+  void Load(u8* in)
+  {
+	  memcpy(&data_offset, in, 8);
+	  memcpy(&data_size, in + 8, 8);
+	  memcpy(&type, in + 16, 4);
+	  memcpy(&program_idx, in + 20, 4);
+	  memcpy(&hashed, in + 24, 4);
+	  memcpy(&sha1_idx, in + 28, 4);
+	  memcpy(&encrypted, in + 32, 4);
+	  memcpy(&key_idx, in + 36, 4);
+	  memcpy(&iv_idx, in + 40, 4);
 	  memcpy(&compressed, in + 44, 4);
 
 	  // Endian swap.
@@ -369,11 +369,11 @@ struct MetadataSectionHeader
 	  compressed = swap32(compressed);
   }
 
-  void Show()
-  {
-	  ConLog.Write("Data offset: 0x%llx",						data_offset);
-	  ConLog.Write("Data size: 0x%llx",							data_size);
-	  ConLog.Write("Type: 0x%08x",								type);
+  void Show()
+  {
+	  ConLog.Write("Data offset: 0x%llx",						data_offset);
+	  ConLog.Write("Data size: 0x%llx",							data_size);
+	  ConLog.Write("Type: 0x%08x",								type);
 	  ConLog.Write("Program index: 0x%08x",						program_idx);
 	  ConLog.Write("Hashed: 0x%08x",							hashed);
 	  ConLog.Write("SHA1 index: 0x%08x",						sha1_idx);
@@ -389,10 +389,10 @@ struct SectionHash {
   u8 padding[12];
   u8 hmac_key[64];
 
-  void Load(vfsStream& f)
-  {
+  void Load(vfsStream& f)
+  {
 	  f.Read(sha1, 20);
-	  f.Read(padding, 12);
+	  f.Read(padding, 12);
 	  f.Read(hmac_key, 64);
   }
 };
@@ -409,12 +409,12 @@ struct CapabilitiesInfo
   u32 unknown4;
   u32 unknown5;
 
-  void Load(vfsStream& f)
-  {
-	  type					= Read32(f);
-	  capabilities_size		= Read32(f);
-	  next					= Read32(f);
-	  unknown1				= Read32(f);
+  void Load(vfsStream& f)
+  {
+	  type					= Read32(f);
+	  capabilities_size		= Read32(f);
+	  next					= Read32(f);
+	  unknown1				= Read32(f);
 	  unknown2				= Read64(f);
 	  unknown3				= Read64(f);
 	  flags					= Read64(f);
@@ -429,10 +429,10 @@ struct Signature
   u8 s[21];
   u8 padding[6];
 
-  void Load(vfsStream& f)
-  {
+  void Load(vfsStream& f)
+  {
 	  f.Read(r, 21);
-	  f.Read(s, 21);
+	  f.Read(s, 21);
 	  f.Read(padding, 6);
   }
 };
@@ -443,65 +443,65 @@ struct SelfSection
   u64 size;
   u64 offset;
 
-  void Load(vfsStream& f)
-  {
-	  *data				= Read32(f);
-	  size				= Read64(f);
+  void Load(vfsStream& f)
+  {
+	  *data				= Read32(f);
+	  size				= Read64(f);
 	  offset			= Read64(f);
   }
-};
-
-class SELFDecrypter
-{
-	// Main SELF file stream.
-	vfsStream& self_f;
-
-	// SCE, SELF and APP headers.
-	SceHeader sce_hdr;
-	SelfHeader self_hdr;
-	AppInfo app_info;
-	
-	// ELF64 header and program header/section header arrays.
-	Elf64_Ehdr elf64_hdr;
-	Array<Elf64_Shdr> shdr64_arr;
-	Array<Elf64_Phdr> phdr64_arr;
-
-	// ELF32 header and program header/section header arrays.
-	Elf32_Ehdr elf32_hdr;
-	Array<Elf32_Shdr> shdr32_arr;
-	Array<Elf32_Phdr> phdr32_arr;
-
-	// Decryption info structs.
-	Array<SectionInfo> secinfo_arr;
-	SCEVersionInfo scev_info;
-	Array<ControlInfo> ctrlinfo_arr;
-
-	// Metadata structs.
-	MetadataInfo meta_info;
-	MetadataHeader meta_hdr;
-	Array<MetadataSectionHeader> meta_shdr;
-
-	// Internal data buffers.
-	u8 *data_keys;
-	u32 data_keys_length;
-	u8 *data_buf;
-	u32 data_buf_length;
-
-	// Main key vault instance.
-	KeyVault key_v;
-
-public:
-	SELFDecrypter(vfsStream& s);
-	bool MakeElf(const std::string& elf, bool isElf32);
-	bool LoadHeaders(bool isElf32);
-	void ShowHeaders(bool isElf32);
-	bool LoadMetadata();
-	bool DecryptData();
-	bool DecryptNPDRM(u8 *metadata, u32 metadata_size);
-	bool GetKeyFromRap(u8 *content_id, u8 *npdrm_key);
-};
-
-extern bool IsSelf(const std::string& path);
-extern bool IsSelfElf32(const std::string& path);
-extern bool CheckDebugSelf(const std::string& self, const std::string& elf);
-extern bool DecryptSelf(const std::string& elf, const std::string& self);
+};
+
+class SELFDecrypter
+{
+	// Main SELF file stream.
+	vfsStream& self_f;
+
+	// SCE, SELF and APP headers.
+	SceHeader sce_hdr;
+	SelfHeader self_hdr;
+	AppInfo app_info;
+	
+	// ELF64 header and program header/section header arrays.
+	Elf64_Ehdr elf64_hdr;
+	std::vector<Elf64_Shdr> shdr64_arr;
+	std::vector<Elf64_Phdr> phdr64_arr;
+
+	// ELF32 header and program header/section header arrays.
+	Elf32_Ehdr elf32_hdr;
+	std::vector<Elf32_Shdr> shdr32_arr;
+	std::vector<Elf32_Phdr> phdr32_arr;
+
+	// Decryption info structs.
+	std::vector<SectionInfo> secinfo_arr;
+	SCEVersionInfo scev_info;
+	std::vector<ControlInfo> ctrlinfo_arr;
+
+	// Metadata structs.
+	MetadataInfo meta_info;
+	MetadataHeader meta_hdr;
+	std::vector<MetadataSectionHeader> meta_shdr;
+
+	// Internal data buffers.
+	u8 *data_keys;
+	u32 data_keys_length;
+	u8 *data_buf;
+	u32 data_buf_length;
+
+	// Main key vault instance.
+	KeyVault key_v;
+
+public:
+	SELFDecrypter(vfsStream& s);
+	bool MakeElf(const std::string& elf, bool isElf32);
+	bool LoadHeaders(bool isElf32);
+	void ShowHeaders(bool isElf32);
+	bool LoadMetadata();
+	bool DecryptData();
+	bool DecryptNPDRM(u8 *metadata, u32 metadata_size);
+	bool GetKeyFromRap(u8 *content_id, u8 *npdrm_key);
+};
+
+extern bool IsSelf(const std::string& path);
+extern bool IsSelfElf32(const std::string& path);
+extern bool CheckDebugSelf(const std::string& self, const std::string& elf);
+extern bool DecryptSelf(const std::string& elf, const std::string& self);
diff --git a/rpcs3/Crypto/utils.cpp b/rpcs3/Crypto/utils.cpp
index 13eb434d89..1f682bfc35 100644
--- a/rpcs3/Crypto/utils.cpp
+++ b/rpcs3/Crypto/utils.cpp
@@ -1,12 +1,12 @@
-#include "stdafx.h"
-#include "utils.h"
-
-// Endian swap auxiliary functions.
+#include "stdafx.h"
+#include "utils.h"
+
+// Endian swap auxiliary functions.
 u16 swap16(u16 i)
-{
-	return ((i & 0xFF00) >>  8) | ((i & 0xFF) << 8);
-}
-
+{
+	return ((i & 0xFF00) >>  8) | ((i & 0xFF) << 8);
+}
+
 u32 swap32(u32 i)
 {
 	return ((i & 0xFF000000) >> 24) | ((i & 0xFF0000) >>  8) | ((i & 0xFF00) <<  8) | ((i & 0xFF) << 24);
@@ -28,32 +28,32 @@ void xor_(unsigned char *dest, unsigned char *src1, unsigned char *src2, int siz
 		dest[i] = src1[i] ^ src2[i];
 	}
 }
-
-// Hex string conversion auxiliary functions.
-u64 hex_to_u64(const char* hex_str)
-{
-	u32 length = strlen(hex_str);
-	u64 tmp = 0;
-	u64 result = 0;
-	char c;
-
-	while (length--)
-	{
-		c = *hex_str++;
-		if((c >= '0') && (c <= '9'))
-			tmp = c - '0';
-		else if((c >= 'a') && (c <= 'f'))
-			tmp = c - 'a' + 10;
-		else if((c >= 'A') && (c <= 'F'))
-			tmp = c - 'A' + 10;
-		else
-			tmp = 0;
-		result |= (tmp << (length * 4));
-	}
-
-	return result;
-}
-
+
+// Hex string conversion auxiliary functions.
+u64 hex_to_u64(const char* hex_str)
+{
+	u32 length = strlen(hex_str);
+	u64 tmp = 0;
+	u64 result = 0;
+	char c;
+
+	while (length--)
+	{
+		c = *hex_str++;
+		if((c >= '0') && (c <= '9'))
+			tmp = c - '0';
+		else if((c >= 'a') && (c <= 'f'))
+			tmp = c - 'a' + 10;
+		else if((c >= 'A') && (c <= 'F'))
+			tmp = c - 'A' + 10;
+		else
+			tmp = 0;
+		result |= (tmp << (length * 4));
+	}
+
+	return result;
+}
+
 void hex_to_bytes(unsigned char *data, const char *hex_str)
 {
 	u32 str_length = strlen(hex_str);
@@ -101,19 +101,19 @@ bool hmac_hash_compare(unsigned char *key, int key_len, unsigned char *in, int i
 {
 	unsigned char *out = new unsigned char[key_len];
 
-	sha1_hmac(key, key_len, in, in_len, out);
-
-	for (int i = 0; i < 0x10; i++)
-	{
-		if (out[i] != hash[i])
+	sha1_hmac(key, key_len, in, in_len, out);
+
+	for (int i = 0; i < 0x10; i++)
+	{
+		if (out[i] != hash[i])
 		{
-			delete[] out;
-			return false;
-		}
-	}
-
-	delete[] out;
-
+			delete[] out;
+			return false;
+		}
+	}
+
+	delete[] out;
+
 	return true;
 }
 
@@ -123,19 +123,19 @@ bool cmac_hash_compare(unsigned char *key, int key_len, unsigned char *in, int i
 
 	aes_context ctx;
 	aes_setkey_enc(&ctx, key, 128);
-	aes_cmac(&ctx, in_len, in, out);
-
-	for (int i = 0; i < key_len; i++)
-	{
-		if (out[i] != hash[i])
+	aes_cmac(&ctx, in_len, in, out);
+
+	for (int i = 0; i < key_len; i++)
+	{
+		if (out[i] != hash[i])
 		{
-			delete[] out;
-			return false;
-		}
-	}
-
-	delete[] out;
-
+			delete[] out;
+			return false;
+		}
+	}
+
+	delete[] out;
+
 	return true;
 }
 
@@ -744,4 +744,4 @@ int lz_decompress(unsigned char *out, unsigned char *in, unsigned int size)
 	delete[] tmp;
 
 	return result;
-}
+}
diff --git a/rpcs3/Crypto/utils.h b/rpcs3/Crypto/utils.h
index 0d9e5eed2c..17ec4e8f5a 100644
--- a/rpcs3/Crypto/utils.h
+++ b/rpcs3/Crypto/utils.h
@@ -1,16 +1,16 @@
-#pragma once
+#pragma once
 #include "aes.h"
-#include "sha1.h"
-
-// Auxiliary functions (endian swap and xor).
-u16 swap16(u16 i);
-u32 swap32(u32 i);
-u64 swap64(u64 i);
+#include "sha1.h"
+
+// Auxiliary functions (endian swap and xor).
+u16 swap16(u16 i);
+u32 swap32(u32 i);
+u64 swap64(u64 i);
 void xor_(unsigned char *dest, unsigned char *src1, unsigned char *src2, int size);
-
-// Hex string conversion auxiliary functions.
-u64 hex_to_u64(const char* hex_str);
-void hex_to_bytes(unsigned char *data, const char *hex_str);
+
+// Hex string conversion auxiliary functions.
+u64 hex_to_u64(const char* hex_str);
+void hex_to_bytes(unsigned char *data, const char *hex_str);
 
 // Crypto functions (AES128-CBC, AES128-ECB, SHA1-HMAC and AES-CMAC).
 void aescbc128_decrypt(unsigned char *key, unsigned char *iv, unsigned char *in, unsigned char *out, int len);
@@ -19,4 +19,4 @@ bool hmac_hash_compare(unsigned char *key, int key_len, unsigned char *in, int i
 bool cmac_hash_compare(unsigned char *key, int key_len, unsigned char *in, int in_len, unsigned char *hash);
 
 // Reverse-engineered custom Lempel–Ziv–Markov based compression (unknown variant of LZRC).
-int lz_decompress(unsigned char *out, unsigned char *in, unsigned int size);
+int lz_decompress(unsigned char *out, unsigned char *in, unsigned int size);
diff --git a/rpcs3/Emu/Audio/cellAudio.h b/rpcs3/Emu/Audio/cellAudio.h
index 709b8c3907..ff6e463065 100644
--- a/rpcs3/Emu/Audio/cellAudio.h
+++ b/rpcs3/Emu/Audio/cellAudio.h
@@ -98,7 +98,7 @@ struct AudioConfig  //custom structure
 	u32 m_port_in_use;
 	u64 counter;
 	u64 start_time;
-	Array<u64> m_keys;
+	std::vector<u64> m_keys;
 
 	AudioConfig()
 		: m_is_audio_initialized(false)
diff --git a/rpcs3/Emu/CPU/CPUDecoder.h b/rpcs3/Emu/CPU/CPUDecoder.h
index 4091e73146..95b168b7af 100644
--- a/rpcs3/Emu/CPU/CPUDecoder.h
+++ b/rpcs3/Emu/CPU/CPUDecoder.h
@@ -7,15 +7,15 @@ class CPUDecoder
 {
 public:
 	virtual u8 DecodeMemory(const u64 address)=0;
+
+	virtual ~CPUDecoder() = default;
 };
 
 template<typename TO>
 class InstrCaller
 {
 public:
-	virtual ~InstrCaller<TO>()
-	{
-	}
+	virtual ~InstrCaller<TO>() = default;
 
 	virtual void operator ()(TO* op, u32 code) const = 0;
 
@@ -334,6 +334,17 @@ public:
 				});
 	}
 
+	virtual ~InstrBase()
+	{
+		if (m_args) {
+			// m_args contains pointers to statically allocated CodeFieldBase objects
+			// We shouldn't call delete on these, they aren't allocated with new
+
+			// The m_args array itself, however, should be deleted
+			delete[] m_args;
+		}
+	}
+
 	__forceinline const std::string& GetName() const
 	{
 		return m_name;
@@ -355,13 +366,13 @@ public:
 		decode(op, code);
 	}
 
-	u32 operator()(const Array<u32>& args) const
+	u32 operator()(const std::vector<u32>& args) const
 	{
 		return encode(args);
 	}
 
 	virtual void decode(TO* op, u32 code) const=0;
-	virtual u32 encode(const Array<u32>& args) const=0;
+	virtual u32 encode(const std::vector<u32>& args) const=0;
 };
 
 template<int _count, typename TO>
@@ -396,12 +407,54 @@ public:
 
 	virtual ~InstrList()
 	{
-		for(int i=0; i<count; ++i)
+		bool deletedErrorFunc = false;
+
+		// Clean up m_instrs
+		for(int i = 0; i < count; ++i)
 		{
-			delete m_instrs[i];
+			InstrCaller<TO>* deleteMe = m_instrs[i];
+
+			if (deleteMe) { // deleteMe will be a nullptr if we've already deleted it through another reference
+				// Remove any instances of pointers to this instruction caller from our m_instrs list
+				m_instrs[i] = nullptr;
+				for (int j = i + 1; j < count; j++) {
+					if (m_instrs[j] == deleteMe) {
+						m_instrs[j] = nullptr;
+					}
+				}
+
+				// If we're deleting the error handler here, remember it so we don't try to delete it again later
+				if (deleteMe == m_error_func) {
+					deletedErrorFunc = true;
+				}
+
+				// Delete the instruction caller
+				delete deleteMe;
+			}
 		}
 
-		delete m_error_func;
+		// Clean up m_instrs_info
+		for (int i = 0; i < count; ++i)
+		{
+			InstrBase<TO>* deleteMe = m_instrs_info[i];
+
+			if (deleteMe) {
+				m_instrs_info[i] = nullptr;
+				for (int j = i + 1; j < count; j++) {
+					if (m_instrs_info[j] == deleteMe) {
+						m_instrs[j] = nullptr;
+					}
+				}
+
+				delete deleteMe;
+			}
+		}
+
+		// If we haven't already deleted our error handler, and we have one, then delete it now
+		if (!deletedErrorFunc && m_error_func)
+		{
+			delete m_error_func;
+		}
 	}
 
 	void set_parent(InstrCaller<TO>* parent, int opcode)
@@ -508,9 +561,9 @@ public:
 		m_list.decode(op, opcode, code);
 	}
 
-	virtual u32 encode(const Array<u32>& args) const
+	virtual u32 encode(const std::vector<u32>& args) const
 	{
-		assert(args.GetCount() == InstrBase<TO>::m_args_count);
+		assert(args.size() == InstrBase<TO>::m_args_count);
 		return m_list.encode(opcode);
 	}
 
@@ -547,9 +600,9 @@ public:
 		m_list.decode(op, opcode, code);
 	}
 
-	virtual u32 encode(const Array<u32>& args) const
+	virtual u32 encode(const std::vector<u32>& args) const
 	{
-		assert(args.GetCount() == InstrBase<TO>::m_args_count);
+		assert(args.size() == InstrBase<TO>::m_args_count);
 		return m_list.encode(opcode) | (*InstrBase<TO>::m_args[0])[args[0]];
 	}
 
@@ -588,9 +641,9 @@ public:
 		m_list.decode(op, opcode, code);
 	}
 
-	virtual u32 encode(const Array<u32>& args) const
+	virtual u32 encode(const std::vector<u32>& args) const
 	{
-		assert(args.GetCount() == InstrBase<TO>::m_args_count);
+		assert(args.size() == InstrBase<TO>::m_args_count);
 		return m_list.encode(opcode) | (*InstrBase<TO>::m_args[0])[args[0]] | (*InstrBase<TO>::m_args[1])[args[1]];
 	}
 
@@ -631,9 +684,9 @@ public:
 		m_list.decode(op, opcode, code);
 	}
 
-	virtual u32 encode(const Array<u32>& args) const
+	virtual u32 encode(const std::vector<u32>& args) const
 	{
-		assert(args.GetCount() == InstrBase<TO>::m_args_count);
+		assert(args.size() == InstrBase<TO>::m_args_count);
 		return m_list.encode(opcode) | (*InstrBase<TO>::m_args[0])[args[0]] | (*InstrBase<TO>::m_args[1])[args[1]] | (*InstrBase<TO>::m_args[2])[args[2]];
 	}
 
@@ -676,9 +729,9 @@ public:
 		m_list.decode(op, opcode, code);
 	}
 
-	virtual u32 encode(const Array<u32>& args) const
+	virtual u32 encode(const std::vector<u32>& args) const
 	{
-		assert(args.GetCount() == InstrBase<TO>::m_args_count);
+		assert(args.size() == InstrBase<TO>::m_args_count);
 		return m_list.encode(opcode) | 
 			(*InstrBase<TO>::m_args[0])[args[0]] |
 			(*InstrBase<TO>::m_args[1])[args[1]] |
@@ -731,9 +784,9 @@ public:
 		m_list.decode(op, opcode, code);
 	}
 
-	virtual u32 encode(const Array<u32>& args) const
+	virtual u32 encode(const std::vector<u32>& args) const
 	{
-		assert(args.GetCount() == InstrBase<TO>::m_args_count);
+		assert(args.size() == InstrBase<TO>::m_args_count);
 		return m_list.encode(opcode) | 
 			(*InstrBase<TO>::m_args[0])[args[0]] |
 			(*InstrBase<TO>::m_args[1])[args[1]] |
@@ -790,9 +843,9 @@ public:
 		m_list.decode(op, opcode, code);
 	}
 
-	virtual u32 encode(const Array<u32>& args) const
+	virtual u32 encode(const std::vector<u32>& args) const
 	{
-		assert(args.GetCount() == InstrBase<TO>::m_args_count);
+		assert(args.size() == InstrBase<TO>::m_args_count);
 		return m_list.encode(opcode) | 
 			(*InstrBase<TO>::m_args[0])[args[0]] |
 			(*InstrBase<TO>::m_args[1])[args[1]] |
diff --git a/rpcs3/Emu/CPU/CPUThread.cpp b/rpcs3/Emu/CPU/CPUThread.cpp
index a318257e37..9ae338ce2d 100644
--- a/rpcs3/Emu/CPU/CPUThread.cpp
+++ b/rpcs3/Emu/CPU/CPUThread.cpp
@@ -26,6 +26,7 @@ CPUThread::CPUThread(CPUThreadType type)
 
 CPUThread::~CPUThread()
 {
+	safe_delete(m_dec);
 }
 
 void CPUThread::Close()
@@ -298,11 +299,11 @@ void CPUThread::Task()
 {
 	if (Ini.HLELogging.GetValue()) ConLog.Write("%s enter", CPUThread::GetFName().c_str());
 
-	const Array<u64>& bp = Emu.GetBreakPoints();
+	const std::vector<u64>& bp = Emu.GetBreakPoints();
 
 	try
 	{
-		for(uint i=0; i<bp.GetCount(); ++i)
+		for(uint i=0; i<bp.size(); ++i)
 		{
 			if(bp[i] == m_offset + PC)
 			{
@@ -335,7 +336,7 @@ void CPUThread::Task()
 				break;
 			}
 
-			for(uint i=0; i<bp.GetCount(); ++i)
+			for(uint i=0; i<bp.size(); ++i)
 			{
 				if(bp[i] == PC)
 				{
diff --git a/rpcs3/Emu/CPU/CPUThread.h b/rpcs3/Emu/CPU/CPUThread.h
index 70a6723c81..b4e2a0784e 100644
--- a/rpcs3/Emu/CPU/CPUThread.h
+++ b/rpcs3/Emu/CPU/CPUThread.h
@@ -196,13 +196,13 @@ public:
 		u64 branch_pc;
 	};
 
-	Stack<CallStackItem> m_call_stack;
+	std::vector<CallStackItem> m_call_stack;
 
 	std::string CallStackToString()
 	{
 		std::string ret = "Call Stack:\n==========\n";
 
-		for(uint i=0; i<m_call_stack.GetCount(); ++i)
+		for(uint i=0; i<m_call_stack.size(); ++i)
 		{
 			ret += fmt::Format("0x%llx -> 0x%llx\n", m_call_stack[i].pc, m_call_stack[i].branch_pc);
 		}
@@ -212,21 +212,25 @@ public:
 
 	void CallStackBranch(u64 pc)
 	{
-		for(int i=m_call_stack.GetCount() - 1; i >= 0; --i)
-		{
-			if(CallStackGetNextPC(m_call_stack[i].pc) == pc)
+		//look if we're jumping back and if so pop the stack back to that position
+		auto res = std::find_if(m_call_stack.rbegin(), m_call_stack.rend(),
+			[&pc, this](CallStackItem &it)
 			{
-				m_call_stack.RemoveAt(i, m_call_stack.GetCount() - i);
-				return;
-			}
+				return CallStackGetNextPC(it.pc) == pc;
+			});
+		if (res != m_call_stack.rend())
+		{
+			m_call_stack.erase((res + 1).base(), m_call_stack.end());
+			return;
 		}
-
+		
+		//add a new entry otherwise
 		CallStackItem new_item;
-
+		
 		new_item.branch_pc = pc;
 		new_item.pc = PC;
-
-		m_call_stack.Push(new_item);
+			
+		m_call_stack.push_back(new_item);
 	}
 
 	virtual u64 CallStackGetNextPC(u64 pc)
diff --git a/rpcs3/Emu/CPU/CPUThreadManager.cpp b/rpcs3/Emu/CPU/CPUThreadManager.cpp
index 48ced91638..d29c5e6373 100644
--- a/rpcs3/Emu/CPU/CPUThreadManager.cpp
+++ b/rpcs3/Emu/CPU/CPUThreadManager.cpp
@@ -18,7 +18,7 @@ CPUThreadManager::~CPUThreadManager()
 void CPUThreadManager::Close()
 {
 	m_raw_spu_num = 0;
-	while(m_threads.GetCount()) RemoveThread(m_threads[0].GetId());
+	while(m_threads.size()) RemoveThread(m_threads[0]->GetId());
 }
 
 CPUThread& CPUThreadManager::AddThread(CPUThreadType type)
@@ -38,7 +38,7 @@ CPUThread& CPUThreadManager::AddThread(CPUThreadType type)
 	
 	new_thread->SetId(Emu.GetIdManager().GetNewID(fmt::Format("%s Thread", new_thread->GetTypeString().c_str()), new_thread));
 
-	m_threads.Add(new_thread);
+	m_threads.push_back(new_thread);
 #ifndef QT_UI
 	wxGetApp().SendDbgCommand(DID_CREATE_THREAD, new_thread);
 #endif
@@ -50,26 +50,34 @@ void CPUThreadManager::RemoveThread(const u32 id)
 {
 	std::lock_guard<std::mutex> lock(m_mtx_thread);
 
-	for(u32 i=0; i<m_threads.GetCount(); ++i)
+	CPUThread* thr = nullptr;
+	u32 thread_index = 0;
+
+	for (u32 i = 0; i < m_threads.size(); ++i)
 	{
-		if(m_threads[i].m_wait_thread_id == id)
+		if (m_threads[i]->m_wait_thread_id == id)
 		{
-			m_threads[i].Wait(false);
-			m_threads[i].m_wait_thread_id = -1;
+			m_threads[i]->Wait(false);
+			m_threads[i]->m_wait_thread_id = -1;
 		}
 
-		if(m_threads[i].GetId() != id) continue;
+		if (m_threads[i]->GetId() != id) continue;
 
-		CPUThread* thr = &m_threads[i];
+		thr = m_threads[i];
+		thread_index = i;
+	}
+
+	if (thr)
+	{
 #ifndef QT_UI
 		wxGetApp().SendDbgCommand(DID_REMOVE_THREAD, thr);
 #endif
 		thr->Close();
 
-		m_threads.RemoveFAt(i);
-		break;
+		m_threads.erase(m_threads.begin() + thread_index);
 	}
 
+	// Removing the ID should trigger the actual deletion of the thread
 	Emu.GetIdManager().RemoveID(id);
 	Emu.CheckStatus();
 }
@@ -80,10 +88,10 @@ s32 CPUThreadManager::GetThreadNumById(CPUThreadType type, u32 id)
 
 	s32 num = 0;
 
-	for(u32 i=0; i<m_threads.GetCount(); ++i)
+	for(u32 i=0; i<m_threads.size(); ++i)
 	{
-		if(m_threads[i].GetId() == id) return num;
-		if(m_threads[i].GetType() == type) num++;
+		if(m_threads[i]->GetId() == id) return num;
+		if(m_threads[i]->GetType() == type) num++;
 	}
 
 	return -1;
@@ -104,8 +112,8 @@ void CPUThreadManager::Exec()
 {
 	std::lock_guard<std::mutex> lock(m_mtx_thread);
 
-	for(u32 i=0; i<m_threads.GetCount(); ++i)
+	for(u32 i=0; i<m_threads.size(); ++i)
 	{
-		m_threads[i].Exec();
+		m_threads[i]->Exec();
 	}
 }
diff --git a/rpcs3/Emu/CPU/CPUThreadManager.h b/rpcs3/Emu/CPU/CPUThreadManager.h
index 1dd312ecbf..c0595dc693 100644
--- a/rpcs3/Emu/CPU/CPUThreadManager.h
+++ b/rpcs3/Emu/CPU/CPUThreadManager.h
@@ -4,10 +4,9 @@ enum CPUThreadType : unsigned char;
 
 class CPUThreadManager
 {
-	ArrayF<CPUThread> m_threads;
+	std::vector<CPUThread*> m_threads;
 	std::mutex m_mtx_thread;
 	wxSemaphore m_sem_task;
-	Stack<u32> m_delete_threads;
 	u32 m_raw_spu_num;
 
 public:
@@ -19,7 +18,7 @@ public:
 	CPUThread& AddThread(CPUThreadType type);
 	void RemoveThread(const u32 id);
 
-	ArrayF<CPUThread>& GetThreads() { return m_threads; }
+	std::vector<CPUThread*>& GetThreads() { return m_threads; }
 	s32 GetThreadNumById(CPUThreadType type, u32 id);
 	CPUThread* GetThread(u32 id);
 
diff --git a/rpcs3/Emu/Cell/PPCDecoder.h b/rpcs3/Emu/Cell/PPCDecoder.h
index fa54d4112c..8c1d55f405 100644
--- a/rpcs3/Emu/Cell/PPCDecoder.h
+++ b/rpcs3/Emu/Cell/PPCDecoder.h
@@ -8,6 +8,8 @@ public:
 	virtual void Decode(const u32 code)=0;
 
 	virtual u8 DecodeMemory(const u64 address);
+
+	virtual ~PPCDecoder() = default;
 };
 
 
diff --git a/rpcs3/Emu/Cell/PPCThread.h b/rpcs3/Emu/Cell/PPCThread.h
index 5b6f91dee2..e7bc4ddbe1 100644
--- a/rpcs3/Emu/Cell/PPCThread.h
+++ b/rpcs3/Emu/Cell/PPCThread.h
@@ -7,7 +7,7 @@ class PPCThread : public CPUThread
 {
 protected:
 	u64 m_args[4];
-	Array<u64> m_argv_addr;
+	std::vector<u64> m_argv_addr;
 
 public:
 	virtual void InitRegs()=0;
@@ -30,4 +30,4 @@ protected:
 	virtual void DoReset() override;
 };
 
-PPCThread* GetCurrentPPCThread();
\ No newline at end of file
+PPCThread* GetCurrentPPCThread();
diff --git a/rpcs3/Emu/Cell/PPCThreadManager.cpp b/rpcs3/Emu/Cell/PPCThreadManager.cpp
index c0d5bafce5..b829ef72e5 100644
--- a/rpcs3/Emu/Cell/PPCThreadManager.cpp
+++ b/rpcs3/Emu/Cell/PPCThreadManager.cpp
@@ -17,7 +17,7 @@ PPCThreadManager::~PPCThreadManager()
 
 void PPCThreadManager::Close()
 {
-	while(m_threads.GetCount()) RemoveThread(m_threads[0].GetId());
+	while(m_threads.size()) RemoveThread(m_threads[0]->GetId());
 }
 
 PPCThread& PPCThreadManager::AddThread(PPCThreadType type)
@@ -36,7 +36,7 @@ PPCThread& PPCThreadManager::AddThread(PPCThreadType type)
 	
 	new_thread->SetId(Emu.GetIdManager().GetNewID(fmt::Format("%s Thread", name), new_thread));
 
-	m_threads.Add(new_thread);
+	m_threads.push_back(new_thread);
 	wxGetApp().SendDbgCommand(DID_CREATE_THREAD, new_thread);
 
 	return *new_thread;
@@ -46,17 +46,17 @@ void PPCThreadManager::RemoveThread(const u32 id)
 {
 	std::lock_guard<std::mutex> lock(m_mtx_thread);
 
-	for(u32 i=0; i<m_threads.GetCount(); ++i)
+	for(u32 i=0; i<m_threads.size(); ++i)
 	{
-		if(m_threads[i].m_wait_thread_id == id)
+		if(m_threads[i]->m_wait_thread_id == id)
 		{
-			m_threads[i].Wait(false);
-			m_threads[i].m_wait_thread_id = -1;
+			m_threads[i]->Wait(false);
+			m_threads[i]->m_wait_thread_id = -1;
 		}
 
-		if(m_threads[i].GetId() != id) continue;
+		if(m_threads[i]->GetId() != id) continue;
 
-		PPCThread* thr = &m_threads[i];
+		PPCThread* thr = m_threads[i];
 		wxGetApp().SendDbgCommand(DID_REMOVE_THREAD, thr);
 		if(thr->IsAlive())
 		{
@@ -69,7 +69,7 @@ void PPCThreadManager::RemoveThread(const u32 id)
 		}
 
 
-		m_threads.RemoveFAt(i);
+		m_threads.erase(m_threads.begin() + i);
 		i--;
 	}
 
@@ -81,10 +81,10 @@ s32 PPCThreadManager::GetThreadNumById(PPCThreadType type, u32 id)
 {
 	s32 num = 0;
 
-	for(u32 i=0; i<m_threads.GetCount(); ++i)
+	for(u32 i=0; i<m_threads.size(); ++i)
 	{
-		if(m_threads[i].GetId() == id) return num;
-		if(m_threads[i].GetType() == type) num++;
+		if(m_threads[i]->GetId() == id) return num;
+		if(m_threads[i]->GetType() == type) num++;
 	}
 
 	return -1;
@@ -92,9 +92,9 @@ s32 PPCThreadManager::GetThreadNumById(PPCThreadType type, u32 id)
 
 PPCThread* PPCThreadManager::GetThread(u32 id)
 {
-	for(u32 i=0; i<m_threads.GetCount(); ++i)
+	for(u32 i=0; i<m_threads.size(); ++i)
 	{
-		if(m_threads[i].GetId() == id) return &m_threads[i];
+		if(m_threads[i]->GetId() == id) return m_threads[i];
 	}
 
 	return nullptr;
@@ -102,9 +102,9 @@ PPCThread* PPCThreadManager::GetThread(u32 id)
 
 void PPCThreadManager::Exec()
 {
-	for(u32 i=0; i<m_threads.GetCount(); ++i)
+	for(u32 i=0; i<m_threads.size(); ++i)
 	{
-		m_threads[i].Exec();
+		m_threads[i]->Exec();
 	}
 }
 #endif
diff --git a/rpcs3/Emu/Cell/PPCThreadManager.h b/rpcs3/Emu/Cell/PPCThreadManager.h
index e1bea459cb..9bb650304c 100644
--- a/rpcs3/Emu/Cell/PPCThreadManager.h
+++ b/rpcs3/Emu/Cell/PPCThreadManager.h
@@ -13,10 +13,9 @@ class PPCThreadManager
 	//IdManager m_threads_id;
 	//ArrayF<PPUThread> m_ppu_threads;
 	//ArrayF<SPUThread> m_spu_threads;
-	ArrayF<PPCThread> m_threads;
+	std::vector<PPCThread *> m_threads;
 	std::mutex m_mtx_thread;
 	wxSemaphore m_sem_task;
-	Stack<u32> m_delete_threads;
 	u32 m_raw_spu_num;
 
 public:
@@ -28,7 +27,7 @@ public:
 	PPCThread& AddThread(PPCThreadType type);
 	void RemoveThread(const u32 id);
 
-	ArrayF<PPCThread>& GetThreads() { return m_threads; }
+	std::vector<PPCThread *>& GetThreads() { return m_threads; }
 	s32 GetThreadNumById(PPCThreadType type, u32 id);
 	PPCThread* GetThread(u32 id);
 	//IdManager& GetIDs() {return m_threads_id;}
diff --git a/rpcs3/Emu/Cell/PPUDecoder.h b/rpcs3/Emu/Cell/PPUDecoder.h
index d5973edb6a..97132b07e9 100644
--- a/rpcs3/Emu/Cell/PPUDecoder.h
+++ b/rpcs3/Emu/Cell/PPUDecoder.h
@@ -9,11 +9,11 @@ class PPUDecoder : public PPCDecoder
 	PPUOpcodes* m_op;
 
 public:
-	PPUDecoder(PPUOpcodes& op) : m_op(&op)
+	PPUDecoder(PPUOpcodes* op) : m_op(op)
 	{
 	}
 
-	~PPUDecoder()
+	virtual ~PPUDecoder()
 	{
 		delete m_op;
 	}
diff --git a/rpcs3/Emu/Cell/PPUInstrTable.h b/rpcs3/Emu/Cell/PPUInstrTable.h
index 52767e92bc..c1bc040877 100644
--- a/rpcs3/Emu/Cell/PPUInstrTable.h
+++ b/rpcs3/Emu/Cell/PPUInstrTable.h
@@ -203,7 +203,9 @@ namespace PPU_instr
 
 	static CodeField<9, 10> STRM;
 
-	static auto main_list = new_list(OPCD, instr_bind(&PPUOpcodes::UNK, GetCode, OPCD, OPCD));
+	//static auto main_list = new_list(OPCD, instr_bind(&PPUOpcodes::UNK, GetCode, OPCD, OPCD));
+	static InstrList<1 << CodeField<0, 5>::size, ::PPUOpcodes> main_list_obj(OPCD, instr_bind(&PPUOpcodes::UNK, GetCode, OPCD, OPCD));
+	static auto main_list = &main_list_obj;
 	static auto g04_list = new_list(main_list, PPU_opcodes::G_04, GD_04);
 	static auto g04_0_list = new_list(g04_list, GD_04_0, instr_bind(&PPUOpcodes::UNK, GetCode, OPCD, GD_04_0));
 	static auto g13_list = new_list(main_list, PPU_opcodes::G_13, GD_13, instr_bind(&PPUOpcodes::UNK, GetCode, OPCD, GD_13));
diff --git a/rpcs3/Emu/Cell/PPUInterpreter.h b/rpcs3/Emu/Cell/PPUInterpreter.h
index 3cb0c0f0d4..6613a70109 100644
--- a/rpcs3/Emu/Cell/PPUInterpreter.h
+++ b/rpcs3/Emu/Cell/PPUInterpreter.h
@@ -2099,7 +2099,7 @@ private:
 			if (Ini.HLELogging.GetValue())
 			{
 				ConLog.Write("'%s' done with code[0x%llx]! #pc: 0x%llx",
-					g_static_funcs_list[CPU.GPR[11]].name, CPU.GPR[3], CPU.PC);
+					g_static_funcs_list[CPU.GPR[11]]->name, CPU.GPR[3], CPU.PC);
 			}
 			break;
 		case 0x22: UNK("HyperCall LV1"); break;
diff --git a/rpcs3/Emu/Cell/PPUProgramCompiler.cpp b/rpcs3/Emu/Cell/PPUProgramCompiler.cpp
index 2f236bdd37..4120c81372 100644
--- a/rpcs3/Emu/Cell/PPUProgramCompiler.cpp
+++ b/rpcs3/Emu/Cell/PPUProgramCompiler.cpp
@@ -1455,9 +1455,9 @@ void CompilePPUProgram::Compile()
 		u32 code;
 
 		{
-			Array<u32> args;
-			args.SetCount(m_args.size());
-			for(uint i=0; i<args.GetCount(); ++i)
+			std::vector<u32> args;
+			args.resize(m_args.size());
+			for(uint i=0; i<args.size(); ++i)
 			{
 				args[i] = m_args[i].value;
 			}
diff --git a/rpcs3/Emu/Cell/PPUThread.cpp b/rpcs3/Emu/Cell/PPUThread.cpp
index 2057b07c2a..63d86ac28b 100644
--- a/rpcs3/Emu/Cell/PPUThread.cpp
+++ b/rpcs3/Emu/Cell/PPUThread.cpp
@@ -51,7 +51,7 @@ void PPUThread::AddArgv(const std::string& arg)
 {
 	m_stack_point -= arg.length() + 1;
 	m_stack_point = Memory.AlignAddr(m_stack_point, 0x10) - 0x10;
-	m_argv_addr.AddCpy(m_stack_point);
+	m_argv_addr.push_back(m_stack_point);
 	Memory.WriteString(m_stack_point, arg);
 }
 
@@ -98,9 +98,9 @@ void PPUThread::InitRegs()
 			GPR[i] = (i+1) * 0x10000;
 	}
 	*/
-	if(m_argv_addr.GetCount())
+	if(m_argv_addr.size())
 	{
-		u64 argc = m_argv_addr.GetCount();
+		u64 argc = m_argv_addr.size();
 		m_stack_point -= 0xc + 4 * argc;
 		u64 argv = m_stack_point;
 
@@ -150,7 +150,8 @@ void PPUThread::DoRun()
 
 	case 1:
 	case 2:
-		m_dec = new PPUDecoder(*new PPUInterpreter(*this));
+		auto ppui = new PPUInterpreter(*this);
+		m_dec = new PPUDecoder(ppui);
 	break;
 	}
 }
@@ -204,4 +205,4 @@ int FPRdouble::Cmp(PPCdouble a, PPCdouble b)
 	if(a == b) return CR_EQ;
 
 	return CR_SO;
-}
\ No newline at end of file
+}
diff --git a/rpcs3/Emu/Cell/PPUThread.h b/rpcs3/Emu/Cell/PPUThread.h
index 6a7cc29273..6bcbe71eee 100644
--- a/rpcs3/Emu/Cell/PPUThread.h
+++ b/rpcs3/Emu/Cell/PPUThread.h
@@ -648,14 +648,14 @@ public:
 	{
 		switch(n)
 		{
-		case 0: value ? CR.cr0 |= bit : CR.cr0 &= ~bit; break;
-		case 1: value ? CR.cr1 |= bit : CR.cr1 &= ~bit; break;
-		case 2: value ? CR.cr2 |= bit : CR.cr2 &= ~bit; break;
-		case 3: value ? CR.cr3 |= bit : CR.cr3 &= ~bit; break;
-		case 4: value ? CR.cr4 |= bit : CR.cr4 &= ~bit; break;
-		case 5: value ? CR.cr5 |= bit : CR.cr5 &= ~bit; break;
-		case 6: value ? CR.cr6 |= bit : CR.cr6 &= ~bit; break;
-		case 7: value ? CR.cr7 |= bit : CR.cr7 &= ~bit; break;
+		case 0: CR.cr0 = (value ? CR.cr0 | bit : CR.cr0 & ~bit); break;
+		case 1: CR.cr1 = (value ? CR.cr1 | bit : CR.cr1 & ~bit); break;
+		case 2: CR.cr2 = (value ? CR.cr2 | bit : CR.cr2 & ~bit); break;
+		case 3: CR.cr3 = (value ? CR.cr3 | bit : CR.cr3 & ~bit); break;
+		case 4: CR.cr4 = (value ? CR.cr4 | bit : CR.cr4 & ~bit); break;
+		case 5: CR.cr5 = (value ? CR.cr5 | bit : CR.cr5 & ~bit); break;
+		case 6: CR.cr6 = (value ? CR.cr6 | bit : CR.cr6 & ~bit); break;
+		case 7: CR.cr7 = (value ? CR.cr7 | bit : CR.cr7 & ~bit); break;
 		}
 	}
 
diff --git a/rpcs3/Emu/Cell/RawSPUThread.cpp b/rpcs3/Emu/Cell/RawSPUThread.cpp
index e3dd598ff0..4cb01dcd9e 100644
--- a/rpcs3/Emu/Cell/RawSPUThread.cpp
+++ b/rpcs3/Emu/Cell/RawSPUThread.cpp
@@ -253,11 +253,11 @@ void RawSPUThread::Task()
 {
 	if (Ini.HLELogging.GetValue()) ConLog.Write("%s enter", PPCThread::GetFName().c_str());
 
-	const Array<u64>& bp = Emu.GetBreakPoints();
+	const std::vector<u64>& bp = Emu.GetBreakPoints();
 
 	try
 	{
-		for(uint i=0; i<bp.GetCount(); ++i)
+		for(uint i=0; i<bp.size(); ++i)
 		{
 			if(bp[i] == m_offset + PC)
 			{
@@ -315,7 +315,7 @@ void RawSPUThread::Task()
 				continue;
 			}
 
-			for(uint i=0; i<bp.GetCount(); ++i)
+			for(uint i=0; i<bp.size(); ++i)
 			{
 				if(bp[i] == PC)
 				{
diff --git a/rpcs3/Emu/Cell/SPUInstrTable.h b/rpcs3/Emu/Cell/SPUInstrTable.h
index bfbe113237..2349f4aab6 100644
--- a/rpcs3/Emu/Cell/SPUInstrTable.h
+++ b/rpcs3/Emu/Cell/SPUInstrTable.h
@@ -39,7 +39,9 @@ namespace SPU_instr
 	static CodeField<18, 31> L_18_31;
 	static CodeField<11> L_11;
 
-	static auto rrr_list = new_list<SPUOpcodes>(RRR);
+	// static auto rrr_list = new_list<SPUOpcodes>(RRR);
+	static InstrList<1 << CodeField<0, 3>::size, SPUOpcodes> rrr_list_obj(RRR, nullptr);
+	static auto rrr_list = &rrr_list_obj;
 	static auto ri18_list = new_list(rrr_list, RI18);
 	static auto ri10_list = new_list(ri18_list, RI10);
 	static auto ri16_list = new_list(ri10_list, RI16);
diff --git a/rpcs3/Emu/Cell/SPUThread.h b/rpcs3/Emu/Cell/SPUThread.h
index 2b1e95d40e..07894259b8 100644
--- a/rpcs3/Emu/Cell/SPUThread.h
+++ b/rpcs3/Emu/Cell/SPUThread.h
@@ -553,7 +553,7 @@ public:
 			{
 				// SPU Thread Group MMIO (LS and SNR)
 				u32 num = (ea & SYS_SPU_THREAD_BASE_MASK) / SYS_SPU_THREAD_OFFSET; // thread number in group
-				if (num >= group->list.GetCount() || !group->list[num])
+				if (num >= group->list.size() || !group->list[num])
 				{
 					ConLog.Error("DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx): invalid thread", ea);
 					return false;
@@ -1288,7 +1288,7 @@ public:
 					reg_value0 = std::stoull(value.substr(16, 31), 0, 16);
 					reg_value1 = std::stoull(value.substr(0, 15), 0, 16);
 				}
-				catch (std::invalid_argument& e)
+				catch (std::invalid_argument& /*e*/)
 				{
 					return false;
 				}
diff --git a/rpcs3/Emu/DbgConsole.cpp b/rpcs3/Emu/DbgConsole.cpp
index 59237c8789..0e534c952a 100644
--- a/rpcs3/Emu/DbgConsole.cpp
+++ b/rpcs3/Emu/DbgConsole.cpp
@@ -26,6 +26,11 @@ DbgConsole::~DbgConsole()
 {
 	ThreadBase::Stop();
 	m_dbg_buffer.Flush();
+
+	safe_delete(m_console);
+	safe_delete(m_color_white);
+	safe_delete(m_color_red);
+	safe_delete(m_output);
 }
 
 void DbgConsole::Write(int ch, const std::string& text)
diff --git a/rpcs3/Emu/DbgConsole.h b/rpcs3/Emu/DbgConsole.h
index d432a4cbf2..c4417b3880 100644
--- a/rpcs3/Emu/DbgConsole.h
+++ b/rpcs3/Emu/DbgConsole.h
@@ -31,7 +31,7 @@ struct _DbgBuffer : public MTPacketBuffer<DbgPacket>
 	{
 		const u32 stext = data.m_text.length();
 
-		m_buffer.Reserve(sizeof(int) + sizeof(u32) + stext);
+		m_buffer.resize(m_buffer.size() + sizeof(int) + sizeof(u32) + stext);
 
 		u32 c_put = m_put;
 
@@ -88,4 +88,4 @@ public:
 private:
 	void OnQuit(wxCloseEvent& event);
 	DECLARE_EVENT_TABLE();
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/FS/VFS.cpp b/rpcs3/Emu/FS/VFS.cpp
index ee49e89f53..0833c471b9 100644
--- a/rpcs3/Emu/FS/VFS.cpp
+++ b/rpcs3/Emu/FS/VFS.cpp
@@ -14,14 +14,19 @@ int sort_devices(const void* _a, const void* _b)
 	return 0;
 }
 
+VFS::~VFS()
+{
+	UnMountAll();
+}
+
 void VFS::Mount(const std::string& ps3_path, const std::string& local_path, vfsDevice* device)
 {
 	UnMount(ps3_path);
 
 	device->SetPath(ps3_path, local_path);
-	m_devices.Add(device);
+	m_devices.push_back(device);
 
-	if(m_devices.GetCount() > 1)
+	if(m_devices.size() > 1)
 	{
 		//std::qsort(m_devices.GetPtr(), m_devices.GetCount(), sizeof(vfsDevice*), sort_devices);
 	}
@@ -29,12 +34,12 @@ void VFS::Mount(const std::string& ps3_path, const std::string& local_path, vfsD
 
 void VFS::UnMount(const std::string& ps3_path)
 {
-	for(u32 i=0; i<m_devices.GetCount(); ++i)
+	for(u32 i=0; i<m_devices.size(); ++i)
 	{
-		if(!m_devices[i].GetPs3Path().compare(ps3_path))
+		if(!m_devices[i]->GetPs3Path().compare(ps3_path))
 		{
-			delete &m_devices[i];
-			m_devices.RemoveFAt(i);
+			delete m_devices[i];
+			m_devices.erase(m_devices.begin() +i);
 
 			return;
 		}
@@ -43,11 +48,12 @@ void VFS::UnMount(const std::string& ps3_path)
 
 void VFS::UnMountAll()
 {
-	for(u32 i=0; i<m_devices.GetCount(); ++i)
+	for(u32 i=0; i<m_devices.size(); ++i)
 	{
-		delete &m_devices[i];
-		m_devices.RemoveFAt(i);
+		delete m_devices[i];
 	}
+
+	m_devices.clear();
 }
 
 vfsFileBase* VFS::OpenFile(const std::string& ps3_path, vfsOpenMode mode) const
@@ -214,9 +220,9 @@ vfsDevice* VFS::GetDevice(const std::string& ps3_path, std::string& path) const
 	u32 max_eq;
 	s32 max_i=-1;
 
-	for(u32 i=0; i<m_devices.GetCount(); ++i)
+	for(u32 i=0; i<m_devices.size(); ++i)
 	{
-		const u32 eq = m_devices[i].CmpPs3Path(ps3_path);
+		const u32 eq = m_devices[i]->CmpPs3Path(ps3_path);
 
 		if(max_i < 0 || eq > max_eq)
 		{
@@ -226,8 +232,8 @@ vfsDevice* VFS::GetDevice(const std::string& ps3_path, std::string& path) const
 	}
 
 	if(max_i < 0) return nullptr;
-	path = vfsDevice::GetWinPath(m_devices[max_i].GetLocalPath(), ps3_path.substr(max_eq, ps3_path.length() - max_eq));
-	return &m_devices[max_i];
+	path = vfsDevice::GetWinPath(m_devices[max_i]->GetLocalPath(), ps3_path.substr(max_eq, ps3_path.length() - max_eq));
+	return m_devices[max_i];
 }
 
 vfsDevice* VFS::GetDeviceLocal(const std::string& local_path, std::string& path) const
@@ -239,9 +245,9 @@ vfsDevice* VFS::GetDeviceLocal(const std::string& local_path, std::string& path)
 	file_path.Normalize();
 	std::string mormalized_path = fmt::ToUTF8(file_path.GetFullPath());
 
-	for(u32 i=0; i<m_devices.GetCount(); ++i)
+	for(u32 i=0; i<m_devices.size(); ++i)
 	{
-		const u32 eq = m_devices[i].CmpLocalPath(mormalized_path);
+		const u32 eq = m_devices[i]->CmpLocalPath(mormalized_path);
 
 		if(max_i < 0 || eq > max_eq)
 		{
@@ -252,8 +258,8 @@ vfsDevice* VFS::GetDeviceLocal(const std::string& local_path, std::string& path)
 
 	if(max_i < 0) return nullptr;
 
-	path = vfsDevice::GetPs3Path(m_devices[max_i].GetPs3Path(), local_path.substr(max_eq, local_path.length() - max_eq));
-	return &m_devices[max_i];
+	path = vfsDevice::GetPs3Path(m_devices[max_i]->GetPs3Path(), local_path.substr(max_eq, local_path.length() - max_eq));
+	return m_devices[max_i];
 }
 
 void VFS::Init(const std::string& path)
diff --git a/rpcs3/Emu/FS/VFS.h b/rpcs3/Emu/FS/VFS.h
index f88a8321e0..95434cb4ea 100644
--- a/rpcs3/Emu/FS/VFS.h
+++ b/rpcs3/Emu/FS/VFS.h
@@ -41,7 +41,14 @@ struct VFSManagerEntry
 
 struct VFS
 {
-	ArrayF<vfsDevice> m_devices;
+	~VFS();
+
+	//TODO: find out where these are supposed to be deleted or just make it shared_ptr
+	//and also make GetDevice and GetDeviceLocal return shared_ptr then.
+	// A vfsDevice will be deleted when they're unmounted or the VFS struct is destroyed.
+	// This will cause problems if other code stores the pointer returned by GetDevice/GetDeviceLocal
+	// and tries to use it after the device is unmounted.
+	std::vector<vfsDevice *> m_devices;
 	void Mount(const std::string& ps3_path, const std::string& local_path, vfsDevice* device);
 	void UnMount(const std::string& ps3_path);
 	void UnMountAll();
@@ -62,4 +69,4 @@ struct VFS
 
 	void Init(const std::string& path);
 	void SaveLoadDevices(std::vector<VFSManagerEntry>& res, bool is_load);
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/FS/vfsDir.cpp b/rpcs3/Emu/FS/vfsDir.cpp
index e4989afa4a..5df20734a5 100644
--- a/rpcs3/Emu/FS/vfsDir.cpp
+++ b/rpcs3/Emu/FS/vfsDir.cpp
@@ -33,7 +33,7 @@ bool vfsDir::IsExists(const std::string& path) const
 	return m_stream->IsExists(path); // Crash (Access violation reading location 0x0000000000000000)
 }
 
-const Array<DirEntryInfo>& vfsDir::GetEntries() const
+const std::vector<DirEntryInfo>& vfsDir::GetEntries() const
 {
 	return m_stream->GetEntries();
 }
diff --git a/rpcs3/Emu/FS/vfsDir.h b/rpcs3/Emu/FS/vfsDir.h
index 3db6d11388..09c8ee197d 100644
--- a/rpcs3/Emu/FS/vfsDir.h
+++ b/rpcs3/Emu/FS/vfsDir.h
@@ -13,7 +13,7 @@ public:
 	virtual bool Open(const std::string& path) override;
 	virtual bool IsOpened() const override;
 	virtual bool IsExists(const std::string& path) const override;
-	virtual const Array<DirEntryInfo>& GetEntries() const override;
+	virtual const std::vector<DirEntryInfo>& GetEntries() const override;
 	virtual void Close() override;
 	virtual std::string GetPath() const override;
 
@@ -22,4 +22,4 @@ public:
 	virtual bool Rename(const std::string& from, const std::string& to) override;
 	virtual bool Remove(const std::string& path) override;
 	virtual const DirEntryInfo* Read() override;
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/FS/vfsDirBase.cpp b/rpcs3/Emu/FS/vfsDirBase.cpp
index 6589c8b070..a7e212019e 100644
--- a/rpcs3/Emu/FS/vfsDirBase.cpp
+++ b/rpcs3/Emu/FS/vfsDirBase.cpp
@@ -34,7 +34,7 @@ bool vfsDirBase::IsExists(const std::string& path) const
 	return wxDirExists(fmt::FromUTF8(path));
 }
 
-const Array<DirEntryInfo>& vfsDirBase::GetEntries() const
+const std::vector<DirEntryInfo>& vfsDirBase::GetEntries() const
 {
 	return m_entries;
 }
@@ -42,7 +42,7 @@ const Array<DirEntryInfo>& vfsDirBase::GetEntries() const
 void vfsDirBase::Close()
 {
 	m_cwd = "";
-	m_entries.Clear();
+	m_entries.clear();
 }
 
 std::string vfsDirBase::GetPath() const
@@ -52,8 +52,8 @@ std::string vfsDirBase::GetPath() const
 
 const DirEntryInfo* vfsDirBase::Read()
 {
-	if (m_pos >= m_entries.GetCount())
+	if (m_pos >= m_entries.size())
 		return nullptr;
 
 	return &m_entries[m_pos++];
-}
\ No newline at end of file
+}
diff --git a/rpcs3/Emu/FS/vfsDirBase.h b/rpcs3/Emu/FS/vfsDirBase.h
index 00549c8e64..c888f60cab 100644
--- a/rpcs3/Emu/FS/vfsDirBase.h
+++ b/rpcs3/Emu/FS/vfsDirBase.h
@@ -31,7 +31,7 @@ class vfsDirBase
 {
 protected:
 	std::string m_cwd;
-	Array<DirEntryInfo> m_entries;
+	std::vector<DirEntryInfo> m_entries;
 	uint m_pos;
 	vfsDevice* m_device;
 
@@ -42,7 +42,7 @@ public:
 	virtual bool Open(const std::string& path);
 	virtual bool IsOpened() const;
 	virtual bool IsExists(const std::string& path) const;
-	virtual const Array<DirEntryInfo>& GetEntries() const;
+	virtual const std::vector<DirEntryInfo>& GetEntries() const;
 	virtual void Close();
 	virtual std::string GetPath() const;
 
@@ -51,4 +51,4 @@ public:
 	virtual bool Rename(const std::string& from, const std::string& to) = 0;
 	virtual bool Remove(const std::string& path) = 0;
 	virtual const DirEntryInfo* Read();
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/FS/vfsLocalDir.cpp b/rpcs3/Emu/FS/vfsLocalDir.cpp
index 676814fcfd..f7e0901807 100644
--- a/rpcs3/Emu/FS/vfsLocalDir.cpp
+++ b/rpcs3/Emu/FS/vfsLocalDir.cpp
@@ -24,7 +24,8 @@ bool vfsLocalDir::Open(const std::string& path)
 	{
 		wxString dir_path = fmt::FromUTF8(path) + name;
 
-		DirEntryInfo& info = m_entries[m_entries.Move(new DirEntryInfo())];
+		m_entries.emplace_back();
+		DirEntryInfo& info = m_entries.back();
 		info.name = fmt::ToUTF8(name);
 
 		info.flags |= dir.Exists(dir_path) ? DirEntry_TypeDir : DirEntry_TypeFile;
diff --git a/rpcs3/Emu/GS/GL/GLBuffers.cpp b/rpcs3/Emu/GS/GL/GLBuffers.cpp
index b7ea6001c7..3b89ac2d53 100644
--- a/rpcs3/Emu/GS/GL/GLBuffers.cpp
+++ b/rpcs3/Emu/GS/GL/GLBuffers.cpp
@@ -20,7 +20,7 @@ void GLBufferObject::Create(GLuint type, u32 count)
 {
 	if(IsCreated()) return;
 
-	m_id.InsertRoomEnd(count);
+	m_id.resize(count);
 	glGenBuffers(count, &m_id[0]);
 	m_type = type;
 }
@@ -29,14 +29,14 @@ void GLBufferObject::Delete()
 {
 	if(!IsCreated()) return;
 
-	glDeleteBuffers(m_id.GetCount(), &m_id[0]);
-	m_id.Clear();
+	glDeleteBuffers(m_id.size(), &m_id[0]);
+	m_id.clear();
 	m_type = 0;
 }
 
 void GLBufferObject::Bind(u32 type, u32 num)
 {
-	assert(num < m_id.GetCount());
+	assert(num < m_id.size());
 	glBindBuffer(type, m_id[num]);
 }
 
@@ -75,7 +75,7 @@ void GLBufferObject::SetAttribPointer(int location, int size, int type, int poin
 
 bool GLBufferObject::IsCreated() const
 {
-	return m_id.GetCount() != 0;
+	return m_id.size() != 0;
 }
 
 GLvbo::GLvbo()
@@ -135,20 +135,20 @@ GLrbo::~GLrbo()
 
 void GLrbo::Create(u32 count)
 {
-	if(m_id.GetCount() == count)
+	if(m_id.size() == count)
 	{
 		return;
 	}
 
 	Delete();
 
-	m_id.SetCount(count);
-	glGenRenderbuffers(count, m_id.GetPtr());
+	m_id.resize(count);
+	glGenRenderbuffers(count, m_id.data());
 }
 
 void GLrbo::Bind(u32 num) const
 {
-	assert(num < m_id.GetCount());
+	assert(num < m_id.size());
 
 	glBindRenderbuffer(GL_RENDERBUFFER, m_id[num]);
 }
@@ -170,18 +170,18 @@ void GLrbo::Delete()
 		return;
 	}
 
-	glDeleteRenderbuffers(m_id.GetCount(), m_id.GetPtr());
-	m_id.Clear();
+	glDeleteRenderbuffers(m_id.size(), m_id.data());
+	m_id.clear();
 }
 
 bool GLrbo::IsCreated() const
 {
-	return m_id.GetCount();
+	return m_id.size();
 }
 
 u32 GLrbo::GetId(u32 num) const
 {
-	assert(num < m_id.GetCount());
+	assert(num < m_id.size());
 	return m_id[num];
 }
 
diff --git a/rpcs3/Emu/GS/GL/GLBuffers.h b/rpcs3/Emu/GS/GL/GLBuffers.h
index 6f66f8196d..dfd58a8595 100644
--- a/rpcs3/Emu/GS/GL/GLBuffers.h
+++ b/rpcs3/Emu/GS/GL/GLBuffers.h
@@ -4,7 +4,7 @@
 struct GLBufferObject
 {
 protected:
-	Array<GLuint> m_id;
+	std::vector<GLuint> m_id;
 	GLuint m_type;
 	
 public:
@@ -51,7 +51,7 @@ public:
 class GLrbo
 {
 protected:
-	Array<GLuint> m_id;
+	std::vector<GLuint> m_id;
 
 public:
 	GLrbo();
@@ -88,4 +88,4 @@ public:
 	static void Unbind(u32 type);
 	void Delete();
 	bool IsCreated() const;
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/GS/GL/GLFragmentProgram.cpp b/rpcs3/Emu/GS/GL/GLFragmentProgram.cpp
index 6b5addd742..7d1d064ef5 100644
--- a/rpcs3/Emu/GS/GL/GLFragmentProgram.cpp
+++ b/rpcs3/Emu/GS/GL/GLFragmentProgram.cpp
@@ -229,20 +229,11 @@ std::string GLFragmentDecompilerThread::BuildCode()
 
 	std::string p;
 
-	for(u32 i=0; i<m_parr.params.GetCount(); ++i)
+	for(u32 i=0; i<m_parr.params.size(); ++i)
 	{
 		p += m_parr.params[i].Format();
 	}
 
-	//return "#version 330\n\
-\n\
-out vec3 color;\n\
-in vec4 tc1;\n\
-\n\
-void main()\n\
-{\n\
-	color = tc1.rgb;\n\
-}";
 	return std::string("#version 330\n"
 					   "\n"
 					   + p + "\n"
@@ -348,12 +339,12 @@ void GLFragmentDecompilerThread::Task()
 
 	m_shader = BuildCode();
 	main.clear();
-	m_parr.params.Clear();
+	m_parr.params.clear();
 }
 
 GLShaderProgram::GLShaderProgram() 
 	: m_decompiler_thread(nullptr)
-	, id(0)
+	, m_id(0)
 {
 }
 
@@ -374,11 +365,22 @@ GLShaderProgram::~GLShaderProgram()
 	Delete();
 }
 
+void GLShaderProgram::Wait()
+{
+	if(m_decompiler_thread && m_decompiler_thread->IsAlive())
+	{
+		m_decompiler_thread->Join();
+	}
+}
+
 void GLShaderProgram::Decompile(RSXShaderProgram& prog)
 {
-#if 0
-	FragmentDecompilerThread(shader, parr, addr).Entry();
-#else
+	GLFragmentDecompilerThread decompiler(m_shader, m_parr, prog.addr, prog.size, prog.ctrl);
+	decompiler.Task();
+}
+
+void GLShaderProgram::DecompileAsync(RSXShaderProgram& prog)
+{
 	if(m_decompiler_thread)
 	{
 		Wait();
@@ -391,59 +393,59 @@ void GLShaderProgram::Decompile(RSXShaderProgram& prog)
 		m_decompiler_thread = nullptr;
 	}
 
-	m_decompiler_thread = new GLFragmentDecompilerThread(shader, parr, prog.addr, prog.size, prog.ctrl);
+	m_decompiler_thread = new GLFragmentDecompilerThread(m_shader, m_parr, prog.addr, prog.size, prog.ctrl);
 	m_decompiler_thread->Start();
-#endif
 }
 
 void GLShaderProgram::Compile()
 {
-	if(id) glDeleteShader(id);
+	if (m_id) glDeleteShader(m_id);
 
-	id = glCreateShader(GL_FRAGMENT_SHADER);
+	m_id = glCreateShader(GL_FRAGMENT_SHADER);
 
-	const char* str = shader.c_str();
-	const int strlen = shader.length();
+	const char* str = m_shader.c_str();
+	const int strlen = m_shader.length();
 
-	glShaderSource(id, 1, &str, &strlen);
-	glCompileShader(id);
+	glShaderSource(m_id, 1, &str, &strlen);
+	glCompileShader(m_id);
 
-	GLint r = GL_FALSE;
-	glGetShaderiv(id, GL_COMPILE_STATUS, &r);
-	if(r != GL_TRUE)
+	GLint compileStatus = GL_FALSE;
+	glGetShaderiv(m_id, GL_COMPILE_STATUS, &compileStatus); // Determine the result of the glCompileShader call
+	if (compileStatus != GL_TRUE) // If the shader failed to compile...
 	{
-		glGetShaderiv(id, GL_INFO_LOG_LENGTH, &r);
+		GLint infoLength;
+		glGetShaderiv(m_id, GL_INFO_LOG_LENGTH, &infoLength); // Retrieve the length in bytes (including trailing NULL) of the shader info log
 
-		if(r)
+		if (infoLength > 0)
 		{
-			char* buf = new char[r+1];
 			GLsizei len;
-			memset(buf, 0, r+1);
-			glGetShaderInfoLog(id, r, &len, buf);
-			ConLog.Error("Failed to compile shader: %s", buf);
+			char* buf = new char[infoLength]; // Buffer to store infoLog
+
+			glGetShaderInfoLog(m_id, infoLength, &len, buf); // Retrieve the shader info log into our buffer
+			ConLog.Error("Failed to compile shader: %s", buf); // Write log to the console
+
 			delete[] buf;
 		}
 
-		ConLog.Write(shader.c_str());
-		Emu.Pause();
+		ConLog.Write(m_shader.c_str()); // Log the text of the shader that failed to compile
+		Emu.Pause(); // Pause the emulator, we can't really continue from here
 	}
-	//else ConLog.Write("Shader compiled successfully!");
 }
 
 void GLShaderProgram::Delete()
 {
-	for(u32 i=0; i<parr.params.GetCount(); ++i)
+	for (u32 i = 0; i<m_parr.params.size(); ++i)
 	{
-		parr.params[i].items.Clear();
-		parr.params[i].type.clear();
+		m_parr.params[i].items.clear();
+		m_parr.params[i].type.clear();
 	}
 
-	parr.params.Clear();
-	shader.clear();
+	m_parr.params.clear();
+	m_shader.clear();
 
-	if(id)
+	if (m_id)
 	{
-		glDeleteShader(id);
-		id = 0;
+		glDeleteShader(m_id);
+		m_id = 0;
 	}
 }
diff --git a/rpcs3/Emu/GS/GL/GLFragmentProgram.h b/rpcs3/Emu/GS/GL/GLFragmentProgram.h
index b6b2a75ccf..9a284c6941 100644
--- a/rpcs3/Emu/GS/GL/GLFragmentProgram.h
+++ b/rpcs3/Emu/GS/GL/GLFragmentProgram.h
@@ -138,28 +138,65 @@ struct GLFragmentDecompilerThread : public ThreadBase
 	u32 GetData(const u32 d) const { return d << 16 | d >> 16; }
 };
 
-struct GLShaderProgram
+/** Storage for an Fragment Program in the process of of recompilation.
+ *  This class calls OpenGL functions and should only be used from the RSX/Graphics thread.
+ */
+class GLShaderProgram
 {
+public:
 	GLShaderProgram();
 	~GLShaderProgram();
 
-	GLFragmentDecompilerThread* m_decompiler_thread;
-
-	GLParamArray parr;
-
-	std::string shader;
-
-	u32 id;
-	
-	void Wait()
-	{
-		if(m_decompiler_thread && m_decompiler_thread->IsAlive())
-		{
-			m_decompiler_thread->Join();
-		}
-	}
+	/**
+	 * Decompile a fragment shader located in the PS3's Memory.  This function operates synchronously.
+	 * @param prog RSXShaderProgram specifying the location and size of the shader in memory
+	 */
 	void Decompile(RSXShaderProgram& prog);
+
+	/**
+	* Asynchronously decompile a fragment shader located in the PS3's Memory.
+	* When this function is called you must call Wait before GetShaderText() will return valid data.
+	* @param prog RSXShaderProgram specifying the location and size of the shader in memory
+	*/
+	void DecompileAsync(RSXShaderProgram& prog);
+
+	/** Wait for the decompiler task to complete decompilation. */
+	void Wait();
+
+	/** Compile the decompiled fragment shader into a format we can use with OpenGL. */
 	void Compile();
 
+	/** Get the source text for this shader */
+	inline const std::string& GetShaderText() const { return m_shader; }
+
+	/**
+	 * Set the source text for this shader
+	 * @param shaderText supplied shader text
+	 */
+	inline void SetShaderText(const std::string& shaderText) { m_shader = shaderText; }
+
+	/** Get the OpenGL id this shader is bound to */
+	inline u32 GetId() const { return m_id; }
+
+	/** 
+	 * Set the OpenGL id this shader is bound to
+	 * @param id supplied id
+	 */
+	inline void SetId(const u32 id) { m_id = id; }
+
+private:
+	/** Threaded fragment shader decompiler responsible for decompiling this program */
+	GLFragmentDecompilerThread* m_decompiler_thread;
+
+	/** Shader parameter storage */
+	GLParamArray m_parr;
+
+	/** Text of our decompiler shader */
+	std::string m_shader;
+
+	/** OpenGL id this shader is bound to */
+	u32 m_id;
+
+	/** Deletes the shader and any stored information */
 	void Delete();
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/GS/GL/GLGSRender.cpp b/rpcs3/Emu/GS/GL/GLGSRender.cpp
index a8831ba806..4c79809716 100644
--- a/rpcs3/Emu/GS/GL/GLGSRender.cpp
+++ b/rpcs3/Emu/GS/GL/GLGSRender.cpp
@@ -136,11 +136,11 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
 		if(!m_vertex_data[i].IsEnabled() || !m_vertex_data[i].addr) continue;
 
 		const size_t item_size = m_vertex_data[i].GetTypeSize() * m_vertex_data[i].size;
-		const size_t data_size = m_vertex_data[i].data.GetCount() - data_offset * item_size;
-		const u32 pos = m_vdata.GetCount();
+		const size_t data_size = m_vertex_data[i].data.size() - data_offset * item_size;
+		const u32 pos = m_vdata.size();
 
 		cur_offset += data_size;
-		m_vdata.InsertRoomEnd(data_size);
+		m_vdata.resize(m_vdata.size() + data_size);
 		memcpy(&m_vdata[pos], &m_vertex_data[i].data[data_offset * item_size], data_size);
 	}
 
@@ -150,12 +150,12 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
 
 	m_vbo.Create(indexed_draw ? 2 : 1);
 	m_vbo.Bind(0);
-	m_vbo.SetData(&m_vdata[0], m_vdata.GetCount());
+	m_vbo.SetData(&m_vdata[0], m_vdata.size());
 
 	if(indexed_draw)
 	{
 		m_vbo.Bind(GL_ELEMENT_ARRAY_BUFFER, 1);
-		m_vbo.SetData(GL_ELEMENT_ARRAY_BUFFER, &m_indexed_array.m_data[0], m_indexed_array.m_data.GetCount());
+		m_vbo.SetData(GL_ELEMENT_ARRAY_BUFFER, &m_indexed_array.m_data[0], m_indexed_array.m_data.size());
 	}
 
 	checkForGlError("initializing vbo");
@@ -173,7 +173,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
 		switch(m_vertex_data[i].type)
 		{
 		case 1:
-			for(u32 j = 0; j<m_vertex_data[i].data.GetCount(); j+=2)
+			for(u32 j = 0; j<m_vertex_data[i].data.size(); j+=2)
 			{
 				dump.Write(wxString::Format("%d\n", *(u16*)&m_vertex_data[i].data[j]));
 				if(!(((j+2) / 2) % m_vertex_data[i].size)) dump.Write("\n");
@@ -181,7 +181,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
 		break;
 
 		case 2:
-			for(u32 j = 0; j<m_vertex_data[i].data.GetCount(); j+=4)
+			for(u32 j = 0; j<m_vertex_data[i].data.size(); j+=4)
 			{
 				dump.Write(wxString::Format("%.01f\n", *(float*)&m_vertex_data[i].data[j]));
 				if(!(((j+4) / 4) % m_vertex_data[i].size)) dump.Write("\n");
@@ -189,7 +189,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
 		break;
 
 		case 3:
-			for(u32 j = 0; j<m_vertex_data[i].data.GetCount(); j+=2)
+			for(u32 j = 0; j<m_vertex_data[i].data.size(); j+=2)
 			{
 				dump.Write(wxString::Format("%.01f\n", *(float*)&m_vertex_data[i].data[j]));
 				if(!(((j+2) / 2) % m_vertex_data[i].size)) dump.Write("\n");
@@ -197,7 +197,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
 		break;
 
 		case 4:
-			for(u32 j = 0; j<m_vertex_data[i].data.GetCount(); ++j)
+			for(u32 j = 0; j<m_vertex_data[i].data.size(); ++j)
 			{
 				dump.Write(wxString::Format("%d\n", m_vertex_data[i].data[j]));
 				if(!((j+1) % m_vertex_data[i].size)) dump.Write("\n");
@@ -205,7 +205,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
 		break;
 
 		case 5:
-			for(u32 j = 0; j<m_vertex_data[i].data.GetCount(); j+=2)
+			for(u32 j = 0; j<m_vertex_data[i].data.size(); j+=2)
 			{
 				dump.Write(wxString::Format("%d\n", *(u16*)&m_vertex_data[i].data[j]));
 				if(!(((j+2) / 2) % m_vertex_data[i].size)) dump.Write("\n");
@@ -213,7 +213,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
 		break;
 
 		case 7:
-			for(u32 j = 0; j<m_vertex_data[i].data.GetCount(); ++j)
+			for(u32 j = 0; j<m_vertex_data[i].data.size(); ++j)
 			{
 				dump.Write(wxString::Format("%d\n", m_vertex_data[i].data[j]));
 				if(!((j+1) % m_vertex_data[i].size)) dump.Write("\n");
@@ -299,7 +299,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
 
 void GLGSRender::DisableVertexData()
 {
-	m_vdata.Clear();
+	m_vdata.clear();
 	for(u32 i=0; i<m_vertex_count; ++i)
 	{
 		if(!m_vertex_data[i].IsEnabled() || !m_vertex_data[i].addr) continue;
@@ -317,7 +317,7 @@ void GLGSRender::InitVertexData()
 								  0.0f, 0.0f, 0.0f, 1.0f};
 	int l;
 
-	for(u32 i=0; i<m_transform_constants.GetCount(); ++i)
+	for(u32 i=0; i<m_transform_constants.size(); ++i)
 	{
 		const RSXTransformConstant& c = m_transform_constants[i];
 		const std::string name = fmt::Format("vc%u", c.id);
@@ -354,7 +354,7 @@ void GLGSRender::InitFragmentData()
 		return;
 	}
 
-	for(u32 i=0; i<m_fragment_constants.GetCount(); ++i)
+	for(u32 i=0; i<m_fragment_constants.size(); ++i)
 	{
 		const RSXTransformConstant& c = m_fragment_constants[i];
 
@@ -397,12 +397,11 @@ bool GLGSRender::LoadProgram()
 	{
 		ConLog.Warning("FP not found in buffer!");
 		m_shader_prog.Decompile(*m_cur_shader_prog);
-		m_shader_prog.Wait();
 		m_shader_prog.Compile();
 		checkForGlError("m_shader_prog.Compile");
 
 		wxFile f(wxGetCwd() + "/FragmentProgram.txt", wxFile::write);
-		f.Write(m_shader_prog.shader);
+		f.Write(m_shader_prog.GetShaderText());
 	}
 
 	if(m_vp_buf_num == -1)
@@ -433,7 +432,7 @@ bool GLGSRender::LoadProgram()
 				{
 					// TODO: This isn't working perfectly. Is there any better/shorter way to update the program
 					m_vertex_prog.shader = program.vp_shader;
-					m_shader_prog.shader = program.fp_shader;
+					m_shader_prog.SetShaderText(program.fp_shader);
 					m_vertex_prog.Wait();
 					m_vertex_prog.Compile();
 					checkForGlError("m_vertex_prog.Compile");
@@ -441,13 +440,13 @@ bool GLGSRender::LoadProgram()
 					m_shader_prog.Compile();
 					checkForGlError("m_shader_prog.Compile");
 					glAttachShader(m_program.id, m_vertex_prog.id);
-					glAttachShader(m_program.id, m_shader_prog.id);
+					glAttachShader(m_program.id, m_shader_prog.GetId());
 					glLinkProgram(m_program.id);
 					checkForGlError("glLinkProgram");
 					glDetachShader(m_program.id, m_vertex_prog.id);
-					glDetachShader(m_program.id, m_shader_prog.id);
+					glDetachShader(m_program.id, m_shader_prog.GetId());
 					program.vp_id = m_vertex_prog.id;
-					program.fp_id = m_shader_prog.id;
+					program.fp_id = m_shader_prog.GetId();
 					program.modified = false;
 				}
 			}
@@ -456,7 +455,7 @@ bool GLGSRender::LoadProgram()
 	}
 	else
 	{
-		m_program.Create(m_vertex_prog.id, m_shader_prog.id);
+		m_program.Create(m_vertex_prog.id, m_shader_prog.GetId());
 		checkForGlError("m_program.Create");
 		m_prog_buffer.Add(m_program, m_shader_prog, *m_cur_shader_prog, m_vertex_prog, *m_cur_vertex_prog);
 		checkForGlError("m_prog_buffer.Add");
@@ -468,9 +467,9 @@ bool GLGSRender::LoadProgram()
 			RSXDebuggerProgram program;
 			program.id = m_program.id;
 			program.vp_id = m_vertex_prog.id;
-			program.fp_id = m_shader_prog.id;
+			program.fp_id = m_shader_prog.GetId();
 			program.vp_shader = m_vertex_prog.shader;
-			program.fp_shader = m_shader_prog.shader;
+			program.fp_shader = m_shader_prog.GetShaderText();
 			m_debug_programs.push_back(program);
 		}
 	}
@@ -1134,12 +1133,12 @@ void GLGSRender::Flip()
 	else if(m_fbo.IsCreated())
 	{
 		format = GL_RGBA;
-		static Array<u8> pixels;
-		pixels.SetCount(RSXThread::m_width * RSXThread::m_height * 4);
+		static std::vector<u8> pixels;
+		pixels.resize(RSXThread::m_width * RSXThread::m_height * 4);
 		m_fbo.Bind(GL_READ_FRAMEBUFFER);
-		glReadPixels(0, 0, RSXThread::m_width, RSXThread::m_height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, pixels.GetPtr());
+		glReadPixels(0, 0, RSXThread::m_width, RSXThread::m_height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, pixels.data());
 
-		src_buffer = pixels.GetPtr();
+		src_buffer = pixels.data();
 		width = RSXThread::m_width;
 		height = RSXThread::m_height;
 	}
@@ -1199,7 +1198,7 @@ void GLGSRender::Flip()
 	if(m_fbo.IsCreated())
 		m_fbo.Bind();
 
-	for(uint i=0; i<m_post_draw_objs.GetCount(); ++i)
+	for(uint i=0; i<m_post_draw_objs.size(); ++i)
 	{
 		m_post_draw_objs[i].Draw();
 	}
diff --git a/rpcs3/Emu/GS/GL/GLGSRender.h b/rpcs3/Emu/GS/GL/GLGSRender.h
index c0aee1dcb5..92993c346b 100644
--- a/rpcs3/Emu/GS/GL/GLGSRender.h
+++ b/rpcs3/Emu/GS/GL/GLGSRender.h
@@ -78,7 +78,6 @@ public:
 		int format = tex.GetFormat() & ~(0x20 | 0x40);
 		bool is_swizzled = !(tex.GetFormat() & CELL_GCM_TEXTURE_LN);
 
-		glPixelStorei(GL_PACK_ALIGNMENT, tex.m_pitch);
 		char* pixels = (char*)Memory.GetMemFromAddr(GetAddress(tex.GetOffset(), tex.GetLocation()));
 		char* unswizzledPixels;
 
@@ -255,7 +254,9 @@ public:
 	{
 		if(!m_id || !tex.GetOffset() || !tex.GetWidth() || !tex.GetHeight()) return;
 
-		u32* alldata = new u32[tex.GetWidth() * tex.GetHeight()];
+		const u32 texPixelCount = tex.GetWidth() * tex.GetHeight();
+
+		u32* alldata = new u32[texPixelCount];
 
 		Bind();
 
@@ -276,15 +277,15 @@ public:
 
 		{
 			wxFile f(name + ".raw", wxFile::write);
-			f.Write(alldata, tex.GetWidth() * tex.GetHeight() * 4);
+			f.Write(alldata, texPixelCount * 4);
 		}
-		u8* data = new u8[tex.GetWidth() * tex.GetHeight() * 3];
-		u8* alpha = new u8[tex.GetWidth() * tex.GetHeight()];
+		u8* data = new u8[texPixelCount * 3];
+		u8* alpha = new u8[texPixelCount];
 
 		u8* src = (u8*)alldata;
 		u8* dst_d = data;
 		u8* dst_a = alpha;
-		for(u32 i=0; i<tex.GetWidth()*tex.GetHeight();i++)
+		for (u32 i = 0; i < texPixelCount; i++)
 		{
 			*dst_d++ = *src++;
 			*dst_d++ = *src++;
@@ -384,7 +385,7 @@ public:
 		InitializeShaders();
 		m_fp.Compile();
 		m_vp.Compile();
-		m_program.Create(m_vp.id, m_fp.id);
+		m_program.Create(m_vp.id, m_fp.GetId());
 		m_program.Use();
 		InitializeLocations();
 	}
@@ -499,7 +500,7 @@ public:
 			"	gl_Position = in_pos;\n"
 			"}\n";
 
-		m_fp.shader =
+		m_fp.SetShaderText(
 			"#version 330\n"
 			"\n"
 			"in vec2 tc;\n"
@@ -509,7 +510,7 @@ public:
 			"void main()\n"
 			"{\n"
 			"	res = texture(tex0, tc);\n"
-			"}\n";
+			"}\n");
 	}
 
 	void SetTexture(void* pixels, int width, int height)
@@ -540,8 +541,8 @@ class GLGSRender
 	, public GSRender
 {
 private:
-	Array<u8> m_vdata;
-	ArrayF<PostDrawObj> m_post_draw_objs;
+	std::vector<u8> m_vdata;
+	std::vector<PostDrawObj> m_post_draw_objs;
 
 	GLProgram m_program;
 	int m_fp_buf_num;
diff --git a/rpcs3/Emu/GS/GL/GLProgram.cpp b/rpcs3/Emu/GS/GL/GLProgram.cpp
index 75d4087bd9..2ff48e5054 100644
--- a/rpcs3/Emu/GS/GL/GLProgram.cpp
+++ b/rpcs3/Emu/GS/GL/GLProgram.cpp
@@ -8,7 +8,7 @@ GLProgram::GLProgram() : id(0)
 
 int GLProgram::GetLocation(const std::string& name)
 {
-	for(u32 i=0; i<m_locations.GetCount(); ++i)
+	for(u32 i=0; i<m_locations.size(); ++i)
 	{
 		if(!m_locations[i].name.compare(name))
 		{
@@ -16,7 +16,8 @@ int GLProgram::GetLocation(const std::string& name)
 		}
 	}
 	
-	u32 pos = m_locations.Move(new Location());
+	m_locations.emplace_back();
+	u32 pos = m_locations.size()-1;
 	m_locations[pos].name = name;
 
 	m_locations[pos].loc = glGetUniformLocation(id, name.c_str());
@@ -84,7 +85,7 @@ void GLProgram::Create(const u32 vp, const u32 fp)
 void GLProgram::UnUse()
 {
 	id = 0;
-	m_locations.Clear();
+	m_locations.clear();
 }
 
 void GLProgram::Use()
@@ -105,5 +106,5 @@ void GLProgram::Delete()
 	if(!IsCreated()) return;
 	glDeleteProgram(id);
 	id = 0;
-	m_locations.Clear();
+	m_locations.clear();
 }
diff --git a/rpcs3/Emu/GS/GL/GLProgram.h b/rpcs3/Emu/GS/GL/GLProgram.h
index 52faf8ce11..321a2e3cf5 100644
--- a/rpcs3/Emu/GS/GL/GLProgram.h
+++ b/rpcs3/Emu/GS/GL/GLProgram.h
@@ -11,7 +11,7 @@ private:
 		std::string name;
 	};
 
-	Array<Location> m_locations;
+	std::vector<Location> m_locations;
 
 public:
 	u32 id;
@@ -25,4 +25,4 @@ public:
 	void UnUse();
 	void SetTex(u32 index);
 	void Delete();
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/GS/GL/GLProgramBuffer.cpp b/rpcs3/Emu/GS/GL/GLProgramBuffer.cpp
index a4d4a63e4f..cf5c90a7a6 100644
--- a/rpcs3/Emu/GS/GL/GLProgramBuffer.cpp
+++ b/rpcs3/Emu/GS/GL/GLProgramBuffer.cpp
@@ -3,12 +3,12 @@
 
 int GLProgramBuffer::SearchFp(const RSXShaderProgram& rsx_fp, GLShaderProgram& gl_fp)
 {
-	for(u32 i=0; i<m_buf.GetCount(); ++i)
+	for(u32 i=0; i<m_buf.size(); ++i)
 	{
-		if(memcmp(&m_buf[i].fp_data[0], &Memory[rsx_fp.addr], m_buf[i].fp_data.GetCount()) != 0) continue;
+		if(memcmp(&m_buf[i].fp_data[0], &Memory[rsx_fp.addr], m_buf[i].fp_data.size()) != 0) continue;
 
-		gl_fp.id = m_buf[i].fp_id;
-		gl_fp.shader = m_buf[i].fp_shader;
+		gl_fp.SetId(m_buf[i].fp_id);
+		gl_fp.SetShaderText(m_buf[i].fp_shader);
 
 		return i;
 	}
@@ -18,10 +18,10 @@ int GLProgramBuffer::SearchFp(const RSXShaderProgram& rsx_fp, GLShaderProgram& g
 
 int GLProgramBuffer::SearchVp(const RSXVertexProgram& rsx_vp, GLVertexProgram& gl_vp)
 {
-	for(u32 i=0; i<m_buf.GetCount(); ++i)
+	for(u32 i=0; i<m_buf.size(); ++i)
 	{
-		if(m_buf[i].vp_data.GetCount() != rsx_vp.data.GetCount()) continue;
-		if(memcmp(m_buf[i].vp_data.GetPtr(), rsx_vp.data.GetPtr(), rsx_vp.data.GetCount() * 4) != 0) continue;
+		if(m_buf[i].vp_data.size() != rsx_vp.data.size()) continue;
+		if(memcmp(m_buf[i].vp_data.data(), rsx_vp.data.data(), rsx_vp.data.size() * 4) != 0) continue;
 
 		gl_vp.id = m_buf[i].vp_id;
 		gl_vp.shader = m_buf[i].vp_shader.c_str();
@@ -34,14 +34,14 @@ int GLProgramBuffer::SearchVp(const RSXVertexProgram& rsx_vp, GLVertexProgram& g
 
 bool GLProgramBuffer::CmpVP(const u32 a, const u32 b) const
 {
-	if(m_buf[a].vp_data.GetCount() != m_buf[b].vp_data.GetCount()) return false;
-	return memcmp(m_buf[a].vp_data.GetPtr(), m_buf[b].vp_data.GetPtr(), m_buf[a].vp_data.GetCount() * 4) == 0;
+	if(m_buf[a].vp_data.size() != m_buf[b].vp_data.size()) return false;
+	return memcmp(m_buf[a].vp_data.data(), m_buf[b].vp_data.data(), m_buf[a].vp_data.size() * 4) == 0;
 }
 
 bool GLProgramBuffer::CmpFP(const u32 a, const u32 b) const
 {
-	if(m_buf[a].fp_data.GetCount() != m_buf[b].fp_data.GetCount()) return false;
-	return memcmp(m_buf[a].fp_data.GetPtr(), m_buf[b].fp_data.GetPtr(), m_buf[a].fp_data.GetCount()) == 0;
+	if(m_buf[a].fp_data.size() != m_buf[b].fp_data.size()) return false;
+	return memcmp(m_buf[a].fp_data.data(), m_buf[b].fp_data.data(), m_buf[a].fp_data.size()) == 0;
 }
 
 u32 GLProgramBuffer::GetProg(u32 fp, u32 vp) const
@@ -60,7 +60,7 @@ u32 GLProgramBuffer::GetProg(u32 fp, u32 vp) const
 		return m_buf[fp].prog_id;
 	}
 
-	for(u32 i=0; i<m_buf.GetCount(); ++i)
+	for(u32 i=0; i<m_buf.size(); ++i)
 	{
 		if(i == fp || i == vp) continue;
 
@@ -84,46 +84,46 @@ u32 GLProgramBuffer::GetProg(u32 fp, u32 vp) const
 
 void GLProgramBuffer::Add(GLProgram& prog, GLShaderProgram& gl_fp, RSXShaderProgram& rsx_fp, GLVertexProgram& gl_vp, RSXVertexProgram& rsx_vp)
 {
-	GLBufferInfo& new_buf = *new GLBufferInfo();
+	GLBufferInfo new_buf;
 
-	ConLog.Write("Add program (%d):", m_buf.GetCount());
+	ConLog.Write("Add program (%d):", m_buf.size());
 	ConLog.Write("*** prog id = %d", prog.id);
 	ConLog.Write("*** vp id = %d", gl_vp.id);
-	ConLog.Write("*** fp id = %d", gl_fp.id);
-	ConLog.Write("*** vp data size = %d", rsx_vp.data.GetCount() * 4);
+	ConLog.Write("*** fp id = %d", gl_fp.GetId());
+	ConLog.Write("*** vp data size = %d", rsx_vp.data.size() * 4);
 	ConLog.Write("*** fp data size = %d", rsx_fp.size);
 
 	ConLog.Write("*** vp shader = \n%s", gl_vp.shader.c_str());
-	ConLog.Write("*** fp shader = \n%s", gl_fp.shader.c_str());
+	ConLog.Write("*** fp shader = \n%s", gl_fp.GetShaderText().c_str());
 	
 
 	new_buf.prog_id = prog.id;
 	new_buf.vp_id = gl_vp.id;
-	new_buf.fp_id = gl_fp.id;
+	new_buf.fp_id = gl_fp.GetId();
 
-	new_buf.fp_data.AddCpy(&Memory[rsx_fp.addr], rsx_fp.size);
-	new_buf.vp_data.CopyFrom(rsx_vp.data);
+	new_buf.fp_data.insert(new_buf.fp_data.end(),&Memory[rsx_fp.addr], &Memory[rsx_fp.addr] + rsx_fp.size);
+	new_buf.vp_data = rsx_vp.data;
 
 	new_buf.vp_shader = gl_vp.shader;
-	new_buf.fp_shader = gl_fp.shader;
+	new_buf.fp_shader = gl_fp.GetShaderText();
 
-	m_buf.Move(&new_buf);
+	m_buf.push_back(new_buf);
 }
 
 void GLProgramBuffer::Clear()
 {
-	for(u32 i=0; i<m_buf.GetCount(); ++i)
+	for(u32 i=0; i<m_buf.size(); ++i)
 	{
 		glDeleteProgram(m_buf[i].prog_id);
 		glDeleteShader(m_buf[i].fp_id);
 		glDeleteShader(m_buf[i].vp_id);
 
-		m_buf[i].fp_data.Clear();
-		m_buf[i].vp_data.Clear();
+		m_buf[i].fp_data.clear();
+		m_buf[i].vp_data.clear();
 
 		m_buf[i].vp_shader.clear();
 		m_buf[i].fp_shader.clear();
 	}
 
-	m_buf.Clear();
+	m_buf.clear();
 }
diff --git a/rpcs3/Emu/GS/GL/GLProgramBuffer.h b/rpcs3/Emu/GS/GL/GLProgramBuffer.h
index 5156dda59d..623130f164 100644
--- a/rpcs3/Emu/GS/GL/GLProgramBuffer.h
+++ b/rpcs3/Emu/GS/GL/GLProgramBuffer.h
@@ -6,15 +6,15 @@ struct GLBufferInfo
 	u32 prog_id;
 	u32 fp_id;
 	u32 vp_id;
-	Array<u8> fp_data;
-	Array<u32> vp_data;
+	std::vector<u8> fp_data;
+	std::vector<u32> vp_data;
 	std::string fp_shader;
 	std::string vp_shader;
 };
 
 struct GLProgramBuffer
 {
-	Array<GLBufferInfo> m_buf;
+	std::vector<GLBufferInfo> m_buf;
 
 	int SearchFp(const RSXShaderProgram& rsx_fp, GLShaderProgram& gl_fp);
 	int SearchVp(const RSXVertexProgram& rsx_vp, GLVertexProgram& gl_vp);
@@ -26,4 +26,4 @@ struct GLProgramBuffer
 
 	void Add(GLProgram& prog, GLShaderProgram& gl_fp, RSXShaderProgram& rsx_fp, GLVertexProgram& gl_vp, RSXVertexProgram& rsx_vp);
 	void Clear();
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/GS/GL/GLShaderParam.h b/rpcs3/Emu/GS/GL/GLShaderParam.h
index d1b4ad7f4b..f39846da44 100644
--- a/rpcs3/Emu/GS/GL/GLShaderParam.h
+++ b/rpcs3/Emu/GS/GL/GLShaderParam.h
@@ -31,7 +31,7 @@ struct GLParamType
 {
 	const GLParamFlag flag;
 	std::string type;
-	Array<GLParamItem> items;
+	std::vector<GLParamItem> items;
 
 	GLParamType(const GLParamFlag _flag, const std::string& _type)
 		: flag(_flag)
@@ -41,7 +41,7 @@ struct GLParamType
 
 	bool SearchName(const std::string& name)
 	{
-		for(u32 i=0; i<items.GetCount(); ++i)
+		for(u32 i=0; i<items.size(); ++i)
 		{
 			if(items[i].name.compare(name) == 0) return true;
 		}
@@ -53,7 +53,7 @@ struct GLParamType
 	{
 		std::string ret = "";
 
-		for(u32 n=0; n<items.GetCount(); ++n)
+		for(u32 n=0; n<items.size(); ++n)
 		{
 			ret += items[n].location + type + " " + items[n].name;
 			if(!items[n].value.empty())
@@ -69,11 +69,11 @@ struct GLParamType
 
 struct GLParamArray
 {
-	Array<GLParamType> params;
+	std::vector<GLParamType> params;
 
 	GLParamType* SearchParam(const std::string& type)
 	{
-		for(u32 i=0; i<params.GetCount(); ++i)
+		for(u32 i=0; i<params.size(); ++i)
 		{
 			if (params[i].type.compare(type) == 0)
 				return &params[i];
@@ -109,13 +109,13 @@ struct GLParamArray
 
 		if(t)
 		{
-			if(!t->SearchName(name)) t->items.Move(new GLParamItem(name, -1, value));
+			if(!t->SearchName(name)) t->items.emplace_back(name, -1, value);
 		}
 		else
 		{
-			const u32 num = params.GetCount();
-			params.Move(new GLParamType(flag, type));
-			params[num].items.Move(new GLParamItem(name, -1, value));
+			const u32 num = params.size();
+			params.emplace_back(flag, type);
+			params[num].items.emplace_back(name, -1, value);
 		}
 
 		return name;
@@ -128,15 +128,15 @@ struct GLParamArray
 
 		if(t)
 		{
-			if(!t->SearchName(name)) t->items.Move(new GLParamItem(name, location));
+			if(!t->SearchName(name)) t->items.emplace_back(name, location);
 		}
 		else
 		{
-			const u32 num = params.GetCount();
-			params.Move(new GLParamType(flag, type));
-			params[num].items.Move(new GLParamItem(name, location));
+			const u32 num = params.size();
+			params.emplace_back(flag, type);
+			params[num].items.emplace_back(name, location);
 		}
 
 		return name;
 	}
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/GS/GL/GLVertexProgram.cpp b/rpcs3/Emu/GS/GL/GLVertexProgram.cpp
index 567f608618..de73bda412 100644
--- a/rpcs3/Emu/GS/GL/GLVertexProgram.cpp
+++ b/rpcs3/Emu/GS/GL/GLVertexProgram.cpp
@@ -248,15 +248,16 @@ std::string GLVertexDecompilerThread::GetFunc()
 	u32 offset = (d2.iaddrh << 3) | d3.iaddrl;
 	std::string name = fmt::Format("func%u", offset);
 
-	for(uint i=0; i<m_funcs.GetCount(); ++i)
+	for(uint i=0; i<m_funcs.size(); ++i)
 	{
 		if(m_funcs[i].name.compare(name) == 0)
 			return name + "()";
 	}
 
-	uint idx = m_funcs.Add(new FuncInfo());
-	m_funcs[idx].offset = offset;
-	m_funcs[idx].name = name;
+	m_funcs.emplace_back();
+	FuncInfo &idx = m_funcs.back();
+	idx.offset = offset;
+	idx.name = name;
 
 	return name + "()";
 }
@@ -280,7 +281,7 @@ std::string GLVertexDecompilerThread::BuildFuncBody(const FuncInfo& func)
 		if(i != func.offset)
 		{
 			uint call_func = -1;
-			for(uint j=0; j<m_funcs.GetCount(); ++j)
+			for(uint j=0; j<m_funcs.size(); ++j)
 			{
 				if(m_funcs[j].offset == i)
 				{
@@ -306,14 +307,14 @@ std::string GLVertexDecompilerThread::BuildCode()
 {
 	std::string p;
 
-	for(u32 i=0; i<m_parr.params.GetCount(); ++i)
+	for(u32 i=0; i<m_parr.params.size(); ++i)
 	{
 		p += m_parr.params[i].Format();
 	}
 
 	std::string fp;
 
-	for(int i=m_funcs.GetCount() - 1; i>0; --i)
+	for(int i=m_funcs.size() - 1; i>0; --i)
 	{
 		fp += fmt::Format("void %s();\n", m_funcs[i].name.c_str());
 	}
@@ -323,7 +324,7 @@ std::string GLVertexDecompilerThread::BuildCode()
 	f += fmt::Format("void %s()\n{\n\tgl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f);\n\t%s();\n\tgl_Position = gl_Position * scaleOffsetMat;\n}\n",
 		m_funcs[0].name.c_str(), m_funcs[1].name.c_str());
 
-	for(uint i=1; i<m_funcs.GetCount(); ++i)
+	for(uint i=1; i<m_funcs.size(); ++i)
 	{
 		f += fmt::Format("\nvoid %s()\n{\n%s}\n", m_funcs[i].name.c_str(), BuildFuncBody(m_funcs[i]).c_str());
 	}
@@ -341,7 +342,7 @@ std::string GLVertexDecompilerThread::BuildCode()
 
 void GLVertexDecompilerThread::Task()
 {
-	m_parr.params.Clear();
+	m_parr.params.clear();
 
 	for(u32 i=0, intsCount=0;;intsCount++)
 	{
@@ -426,7 +427,7 @@ void GLVertexDecompilerThread::Task()
 
 		if(d3.end)
 		{
-			if(i < m_data.GetCount())
+			if(i < m_data.size())
 				ConLog.Error("Program end before buffer end.");
 
 			break;
@@ -436,7 +437,10 @@ void GLVertexDecompilerThread::Task()
 	m_shader = BuildCode();
 
 	m_body.clear();
-	m_funcs.RemoveAt(2, m_funcs.GetCount() - 2);
+	if (m_funcs.size() > 2)
+	{
+		m_funcs.erase(m_funcs.begin()+2, m_funcs.end());
+	}
 }
 
 GLVertexProgram::GLVertexProgram()
@@ -521,7 +525,7 @@ void GLVertexProgram::Compile()
 
 void GLVertexProgram::Delete()
 {
-	parr.params.Clear();
+	parr.params.clear();
 	shader.clear();
 
 	if(id)
diff --git a/rpcs3/Emu/GS/GL/GLVertexProgram.h b/rpcs3/Emu/GS/GL/GLVertexProgram.h
index 4e9e49b489..117e7f4082 100644
--- a/rpcs3/Emu/GS/GL/GLVertexProgram.h
+++ b/rpcs3/Emu/GS/GL/GLVertexProgram.h
@@ -135,23 +135,23 @@ struct GLVertexDecompilerThread : public ThreadBase
 
 	std::vector<std::string> m_body;
 
-	ArrayF<FuncInfo> m_funcs;
+	std::vector<FuncInfo> m_funcs;
 
 	//wxString main;
 	std::string& m_shader;
-	Array<u32>& m_data;
+	std::vector<u32>& m_data;
 	GLParamArray& m_parr;
 
-	GLVertexDecompilerThread(Array<u32>& data, std::string& shader, GLParamArray& parr)
+	GLVertexDecompilerThread(std::vector<u32>& data, std::string& shader, GLParamArray& parr)
 		: ThreadBase("Vertex Shader Decompiler Thread")
 		, m_data(data)
 		, m_shader(shader)
 		, m_parr(parr)
 	{
-		m_funcs.Add(new FuncInfo());
+		m_funcs.emplace_back();
 		m_funcs[0].offset = 0;
 		m_funcs[0].name = "main";
-		m_funcs.Add(new FuncInfo());
+		m_funcs.emplace_back();
 		m_funcs[1].offset = 0;
 		m_funcs[1].name = "func0";
 		//m_cur_func->body = "\tgl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f);\n";
diff --git a/rpcs3/Emu/GS/RSXThread.cpp b/rpcs3/Emu/GS/RSXThread.cpp
index 56bebee980..98f7ffe0ab 100644
--- a/rpcs3/Emu/GS/RSXThread.cpp
+++ b/rpcs3/Emu/GS/RSXThread.cpp
@@ -36,7 +36,7 @@ void RSXVertexData::Reset()
 	size = 0;
 	type = 0;
 	addr = 0;
-	data.ClearF();
+	data.clear();
 }
 
 void RSXVertexData::Load(u32 start, u32 count)
@@ -45,7 +45,7 @@ void RSXVertexData::Load(u32 start, u32 count)
 
 	const u32 tsize = GetTypeSize();
 
-	data.SetCount((start + count) * tsize * size);
+	data.resize((start + count) * tsize * size);
 
 	for(u32 i=start; i<start + count; ++i)
 	{
@@ -181,6 +181,8 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 
 	u32 index = 0;
 
+	m_used_gcm_commands.insert(cmd);
+
 	//static u32 draw_array_count = 0;
 
 	switch(cmd)
@@ -236,10 +238,10 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 		m_vertex_data[index].Reset();
 		m_vertex_data[index].size = 4;
 		m_vertex_data[index].type = 4;
-		m_vertex_data[index].data.AddCpy(v0);
-		m_vertex_data[index].data.AddCpy(v1);
-		m_vertex_data[index].data.AddCpy(v2);
-		m_vertex_data[index].data.AddCpy(v3);
+		m_vertex_data[index].data.push_back(v0);
+		m_vertex_data[index].data.push_back(v1);
+		m_vertex_data[index].data.push_back(v2);
+		m_vertex_data[index].data.push_back(v3);
 		//ConLog.Warning("index = %d, v0 = 0x%x, v1 = 0x%x, v2 = 0x%x, v3 = 0x%x", index, v0, v1, v2, v3);
 	}
 	break;
@@ -255,7 +257,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 		m_vertex_data[index].Reset();
 		m_vertex_data[index].type = 2;
 		m_vertex_data[index].size = 2;
-		m_vertex_data[index].data.SetCount(sizeof(float) * 2);
+		m_vertex_data[index].data.resize(sizeof(float) * 2);
 		(float&)m_vertex_data[index].data[sizeof(float)*0] = v0;
 		(float&)m_vertex_data[index].data[sizeof(float)*1] = v1;
 
@@ -278,7 +280,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 		m_vertex_data[index].Reset();
 		m_vertex_data[index].type = 2;
 		m_vertex_data[index].size = 4;
-		m_vertex_data[index].data.SetCount(sizeof(float) * 4);
+		m_vertex_data[index].data.resize(sizeof(float) * 4);
 		(float&)m_vertex_data[index].data[sizeof(float)*0] = v0;
 		(float&)m_vertex_data[index].data[sizeof(float)*1] = v1;
 		(float&)m_vertex_data[index].data[sizeof(float)*2] = v2;
@@ -299,7 +301,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 		u32 a0 = ARGS(0);
 		u32 pitch = a0 & 0xFFFFF;
 		u16 depth = a0 >> 20;
-		tex.SetControl3(pitch, depth);
+		tex.SetControl3(depth, pitch);
 	}
 	break;
 
@@ -325,6 +327,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 	case_16(NV4097_SET_TEXTURE_BORDER_COLOR,0x20):
 	{
 	}
+	break;
 
 	case NV4097_SET_SURFACE_FORMAT:
 	{
@@ -528,7 +531,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 		const u32 addr = GetAddress(ARGS(0) & 0x7fffffff, ARGS(0) >> 31);
 		CMD_LOG("num=%d, addr=0x%x", index, addr);
 		m_vertex_data[index].addr = addr;
-		m_vertex_data[index].data.ClearF();
+		m_vertex_data[index].data.clear();
 	}
 	break;
 
@@ -592,8 +595,8 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 				{
 					case 0:
 					{
-						int pos = m_indexed_array.m_data.GetCount();
-						m_indexed_array.m_data.InsertRoomEnd(4);
+						int pos = m_indexed_array.m_data.size();
+						m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 4);
 						index = Memory.Read32(m_indexed_array.m_addr + i * 4);
 						*(u32*)&m_indexed_array.m_data[pos] = index;
 						//ConLog.Warning("index 4: %d", *(u32*)&m_indexed_array.m_data[pos]);
@@ -602,8 +605,8 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 
 					case 1:
 					{
-						int pos = m_indexed_array.m_data.GetCount();
-						m_indexed_array.m_data.InsertRoomEnd(2);
+						int pos = m_indexed_array.m_data.size();
+						m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 2);
 						index = Memory.Read16(m_indexed_array.m_addr + i * 2);
 						//ConLog.Warning("index 2: %d", index);
 						*(u16*)&m_indexed_array.m_data[pos] = index;
@@ -684,7 +687,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 		//ConLog.Warning("NV4097_SET_TRANSFORM_PROGRAM_LOAD: prog = %d", ARGS(0));
 
 		m_cur_vertex_prog = &m_vertex_progs[ARGS(0)];
-		m_cur_vertex_prog->data.Clear();
+		m_cur_vertex_prog->data.clear();
 
 		if(count == 2)
 		{
@@ -705,7 +708,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 			break;
 		}
 
-		for(u32 i=0; i<count; ++i) m_cur_vertex_prog->data.AddCpy(ARGS(i));
+		for(u32 i=0; i<count; ++i) m_cur_vertex_prog->data.push_back(ARGS(i));
 	}
 	break;
 
@@ -745,7 +748,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 			RSXTransformConstant c(id, (float&)x, (float&)y, (float&)z, (float&)w);
 
 			CMD_LOG("SET_TRANSFORM_CONSTANT_LOAD[%d : %d] = (%f, %f, %f, %f)", i, id, c.x, c.y, c.z, c.w);
-			m_transform_constants.AddCpy(c);
+			m_transform_constants.push_back(c);
 		}
 	}
 	break;
@@ -1252,7 +1255,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 		}
 
 		//ConLog.Warning("NV308A_COLOR: [%d]: %f, %f, %f, %f", c.id, c.x, c.y, c.z, c.w);
-		m_fragment_constants.AddCpy(c);
+		m_fragment_constants.push_back(c);
 	}
 	break;
 
@@ -1489,7 +1492,7 @@ void RSXThread::Begin(u32 draw_mode)
 	m_draw_array_count = 0;
 	m_draw_array_first = ~0;
 
-	if(Emu.GetCallbackManager().m_exit_callback.m_callbacks.GetCount())
+	if(Emu.GetCallbackManager().m_exit_callback.m_callbacks.size())
 	{
 		//Emu.GetCallbackManager().m_exit_callback.Handle(0x0121, 0);
 	}
@@ -1499,14 +1502,14 @@ void RSXThread::End()
 {
 	ExecCMD();
 
-	if(Emu.GetCallbackManager().m_exit_callback.m_callbacks.GetCount())
+	if(Emu.GetCallbackManager().m_exit_callback.m_callbacks.size())
 	{
 		//Emu.GetCallbackManager().m_exit_callback.Handle(0x0122, 0);
 	}
 
 	m_indexed_array.Reset();
-	m_fragment_constants.Clear();
-	m_transform_constants.Clear();
+	m_fragment_constants.clear();
+	m_transform_constants.clear();
 	m_cur_shader_prog_num = 0;
 	//m_cur_shader_prog = nullptr;
 
@@ -1562,7 +1565,7 @@ void RSXThread::Task()
 		}
 		if(cmd & CELL_GCM_METHOD_FLAG_CALL)
 		{
-			m_call_stack.Push(get + 4);
+			m_call_stack.push(get + 4);
 			u32 offs = cmd & ~CELL_GCM_METHOD_FLAG_CALL;
 			u32 addr = Memory.RSXIOMem.GetStartAddr() + offs;
 			//ConLog.Warning("rsx call(0x%x) #0x%x - 0x%x - 0x%x", offs, addr, cmd, get);
@@ -1572,7 +1575,8 @@ void RSXThread::Task()
 		if(cmd == CELL_GCM_METHOD_FLAG_RETURN)
 		{
 			//ConLog.Warning("rsx return!");
-			u32 get = m_call_stack.Pop();
+			u32 get = m_call_stack.top();
+			m_call_stack.pop();
 			//ConLog.Warning("rsx return(0x%x)", get);
 			m_ctrl->get = get;
 			continue;
diff --git a/rpcs3/Emu/GS/RSXThread.h b/rpcs3/Emu/GS/RSXThread.h
index 318621b7b9..7fd5e46bd3 100644
--- a/rpcs3/Emu/GS/RSXThread.h
+++ b/rpcs3/Emu/GS/RSXThread.h
@@ -5,6 +5,9 @@
 #include "RSXFragmentProgram.h"
 #include "Emu/SysCalls/Callback.h"
 
+#include <stack>
+#include <set> // For tracking a list of used gcm commands
+
 enum Method
 {
 	CELL_GCM_METHOD_FLAG_NON_INCREMENT = 0x40000000,
@@ -25,7 +28,7 @@ struct RSXVertexData
 	u32 addr;
 	u32 constant_count;
 
-	Array<u8> data;
+	std::vector<u8> data;
 
 	RSXVertexData();
 
@@ -38,7 +41,7 @@ struct RSXVertexData
 
 struct RSXIndexArrayData
 {
-	Array<u8> m_data;
+	std::vector<u8> m_data;
 	int m_type;
 	u32 m_first;
 	u32 m_count;
@@ -59,7 +62,7 @@ struct RSXIndexArrayData
 		m_addr = 0;
 		index_min = ~0;
 		index_max = 0;
-		m_data.Clear();
+		m_data.clear();
 	}
 };
 
@@ -95,7 +98,7 @@ public:
 	static const uint m_tiles_count = 15;
 
 protected:
-	Stack<u32> m_call_stack;
+	std::stack<u32> m_call_stack;
 	CellGcmControl* m_ctrl;
 
 public:
@@ -103,8 +106,8 @@ public:
 	RSXTexture m_textures[m_textures_count];
 	RSXVertexData m_vertex_data[m_vertex_count];
 	RSXIndexArrayData m_indexed_array;
-	Array<RSXTransformConstant> m_fragment_constants;
-	Array<RSXTransformConstant> m_transform_constants;
+	std::vector<RSXTransformConstant> m_fragment_constants;
+	std::vector<RSXTransformConstant> m_transform_constants;
 
 	u32 m_cur_shader_prog_num;
 	RSXShaderProgram m_shader_progs[m_fragment_count];
@@ -382,6 +385,8 @@ public:
 	u8 m_begin_end;
 	bool m_read_buffer;
 
+	std::set<u32> m_used_gcm_commands;
+
 protected:
 	RSXThread()
 		: ThreadBase("RSXThread")
@@ -536,6 +541,8 @@ public:
 		m_cur_shader_prog = nullptr;
 		m_cur_shader_prog_num = 0;
 
+		m_used_gcm_commands.clear();
+
 		OnInit();
 		ThreadBase::Start();
 	}
diff --git a/rpcs3/Emu/GS/RSXVertexProgram.h b/rpcs3/Emu/GS/RSXVertexProgram.h
index e655e78bee..e7b103a688 100644
--- a/rpcs3/Emu/GS/RSXVertexProgram.h
+++ b/rpcs3/Emu/GS/RSXVertexProgram.h
@@ -2,5 +2,5 @@
 
 struct RSXVertexProgram
 {
-	Array<u32> data;
-};
\ No newline at end of file
+	std::vector<u32> data;
+};
diff --git a/rpcs3/Emu/Io/PadHandler.h b/rpcs3/Emu/Io/PadHandler.h
index 4f97edab75..e099e2ef37 100644
--- a/rpcs3/Emu/Io/PadHandler.h
+++ b/rpcs3/Emu/Io/PadHandler.h
@@ -202,9 +202,9 @@ protected:
 	std::vector<Pad> m_pads;
 
 public:
-	virtual ~PadHandlerBase() = default;
 	virtual void Init(const u32 max_connect)=0;
 	virtual void Close()=0;
+	virtual ~PadHandlerBase() = default;
 
 	void Key(const u32 code, bool pressed)
 	{
diff --git a/rpcs3/Emu/Memory/DynamicMemoryBlockBase.inl b/rpcs3/Emu/Memory/DynamicMemoryBlockBase.inl
index 33b80d2ecf..fb87f12d81 100644
--- a/rpcs3/Emu/Memory/DynamicMemoryBlockBase.inl
+++ b/rpcs3/Emu/Memory/DynamicMemoryBlockBase.inl
@@ -2,8 +2,8 @@
 //DynamicMemoryBlockBase
 template<typename PT>
 DynamicMemoryBlockBase<PT>::DynamicMemoryBlockBase()
-	: PT()
-	, m_max_size(0)
+: PT()
+, m_max_size(0)
 {
 }
 
@@ -14,7 +14,7 @@ const u32 DynamicMemoryBlockBase<PT>::GetUsedSize() const
 
 	u32 size = 0;
 
-	for(u32 i=0; i<m_allocated.GetCount(); ++i)
+	for (u32 i = 0; i<m_allocated.size(); ++i)
 	{
 		size += m_allocated[i].size;
 	}
@@ -53,10 +53,10 @@ MemoryBlock* DynamicMemoryBlockBase<PT>::SetRange(const u64 start, const u32 siz
 	MemoryBlock::SetRange(start, 0);
 
 	const u32 page_count = m_max_size >> 12;
-	m_pages.SetCount(page_count);
-	m_locked.SetCount(page_count);
-	memset(m_pages.GetPtr(), 0, sizeof(u8*) * page_count);
-	memset(m_locked.GetPtr(), 0, sizeof(u8*) * page_count);
+	m_pages.resize(page_count);
+	m_locked.resize(page_count);
+	memset(m_pages.data(), 0, sizeof(u8*) * page_count);
+	memset(m_locked.data(), 0, sizeof(u8*) * page_count);
 
 	return this;
 }
@@ -66,11 +66,11 @@ void DynamicMemoryBlockBase<PT>::Delete()
 {
 	std::lock_guard<std::mutex> lock(m_lock);
 
-	m_allocated.Clear();
+	m_allocated.clear();
 	m_max_size = 0;
 
-	m_pages.Clear();
-	m_locked.Clear();
+	m_pages.clear();
+	m_locked.clear();
 
 	MemoryBlock::Delete();
 }
@@ -82,22 +82,22 @@ bool DynamicMemoryBlockBase<PT>::AllocFixed(u64 addr, u32 size)
 
 	addr &= ~4095; // align start address
 
-	if(!IsInMyRange(addr, size))
+	if (!IsInMyRange(addr, size))
 	{
 		assert(0);
 		return false;
 	}
 
-	if(IsMyAddress(addr) || IsMyAddress(addr + size - 1))
+	if (IsMyAddress(addr) || IsMyAddress(addr + size - 1))
 	{
 		return false;
 	}
 
 	std::lock_guard<std::mutex> lock(m_lock);
 
-	for(u32 i=0; i<m_allocated.GetCount(); ++i)
+	for (u32 i = 0; i<m_allocated.size(); ++i)
 	{
-		if(addr >= m_allocated[i].addr && addr < m_allocated[i].addr + m_allocated[i].size) return false;
+		if (addr >= m_allocated[i].addr && addr < m_allocated[i].addr + m_allocated[i].size) return false;
 	}
 
 	AppendMem(addr, size);
@@ -108,7 +108,9 @@ bool DynamicMemoryBlockBase<PT>::AllocFixed(u64 addr, u32 size)
 template<typename PT>
 void DynamicMemoryBlockBase<PT>::AppendMem(u64 addr, u32 size) /* private */
 {
-	u8* pointer = (u8*)m_allocated[m_allocated.Move(new MemBlockInfo(addr, size))].mem;
+	//u8* pointer = (u8*)m_allocated[m_allocated.Move(new MemBlockInfo(addr, size))].mem;
+	m_allocated.emplace_back(addr, size);
+	u8* pointer = (u8*) m_allocated.back().mem;
 
 	const u32 first = MemoryBlock::FixAddr(addr) >> 12;
 
@@ -141,13 +143,13 @@ u64 DynamicMemoryBlockBase<PT>::AllocAlign(u32 size, u32 align)
 
 	std::lock_guard<std::mutex> lock(m_lock);
 
-	for(u64 addr = MemoryBlock::GetStartAddr(); addr <= MemoryBlock::GetEndAddr() - exsize;)
+	for (u64 addr = MemoryBlock::GetStartAddr(); addr <= MemoryBlock::GetEndAddr() - exsize;)
 	{
 		bool is_good_addr = true;
 
-		for(u32 i=0; i<m_allocated.GetCount(); ++i)
+		for (u32 i = 0; i<m_allocated.size(); ++i)
 		{
-			if((addr >= m_allocated[i].addr && addr < m_allocated[i].addr + m_allocated[i].size) ||
+			if ((addr >= m_allocated[i].addr && addr < m_allocated[i].addr + m_allocated[i].size) ||
 				(m_allocated[i].addr >= addr && m_allocated[i].addr < addr + exsize))
 			{
 				is_good_addr = false;
@@ -156,7 +158,7 @@ u64 DynamicMemoryBlockBase<PT>::AllocAlign(u32 size, u32 align)
 			}
 		}
 
-		if(!is_good_addr) continue;
+		if (!is_good_addr) continue;
 
 		if (align)
 		{
@@ -182,7 +184,7 @@ bool DynamicMemoryBlockBase<PT>::Free(u64 addr)
 {
 	std::lock_guard<std::mutex> lock(m_lock);
 
-	for (u32 num = 0; num < m_allocated.GetCount(); num++)
+	for (u32 num = 0; num < m_allocated.size(); num++)
 	{
 		if (addr == m_allocated[num].addr)
 		{
@@ -205,13 +207,13 @@ bool DynamicMemoryBlockBase<PT>::Free(u64 addr)
 				m_locked[i] = nullptr;
 			}
 
-			m_allocated.RemoveAt(num);
+			m_allocated.erase(m_allocated.begin() + num);
 			return true;
 		}
 	}
 
 	ConLog.Error("DynamicMemoryBlock::Free(addr=0x%llx): failed", addr);
-	for (u32 i = 0; i < m_allocated.GetCount(); i++)
+	for (u32 i = 0; i < m_allocated.size(); i++)
 	{
 		ConLog.Write("*** Memory Block: addr = 0x%llx, size = 0x%x", m_allocated[i].addr, m_allocated[i].size);
 	}
@@ -223,7 +225,7 @@ u8* DynamicMemoryBlockBase<PT>::GetMem(u64 addr) const // lock-free, addr is fix
 {
 	const u32 index = addr >> 12;
 
-	if (index < m_pages.GetCount())
+	if (index < m_pages.size())
 	{
 		if (u8* res = m_pages[index])
 		{
@@ -243,7 +245,7 @@ bool DynamicMemoryBlockBase<PT>::IsLocked(u64 addr) // lock-free
 	{
 		const u32 index = MemoryBlock::FixAddr(addr) >> 12;
 
-		if (index < m_locked.GetCount())
+		if (index < m_locked.size())
 		{
 			if (m_locked[index]) return true;
 		}
@@ -259,13 +261,13 @@ bool DynamicMemoryBlockBase<PT>::Lock(u64 addr, u32 size)
 
 	addr &= ~4095; // align start address
 
-	if(!IsInMyRange(addr, size))
+	if (!IsInMyRange(addr, size))
 	{
 		assert(0);
 		return false;
 	}
 
-	if(IsMyAddress(addr) || IsMyAddress(addr + size - 1))
+	if (IsMyAddress(addr) || IsMyAddress(addr + size - 1))
 	{
 		return false;
 	}
@@ -291,18 +293,18 @@ bool DynamicMemoryBlockBase<PT>::Lock(u64 addr, u32 size)
 
 template<typename PT>
 bool DynamicMemoryBlockBase<PT>::Unlock(u64 addr, u32 size)
-{	
+{
 	size = PAGE_4K(size); // align size
 
 	addr &= ~4095; // align start address
 
-	if(!IsInMyRange(addr, size))
+	if (!IsInMyRange(addr, size))
 	{
 		assert(0);
 		return false;
 	}
 
-	if(IsMyAddress(addr) || IsMyAddress(addr + size - 1))
+	if (IsMyAddress(addr) || IsMyAddress(addr + size - 1))
 	{
 		return false;
 	}
diff --git a/rpcs3/Emu/Memory/Memory.cpp b/rpcs3/Emu/Memory/Memory.cpp
index 234432aaab..b71bea4e6c 100644
--- a/rpcs3/Emu/Memory/Memory.cpp
+++ b/rpcs3/Emu/Memory/Memory.cpp
@@ -559,7 +559,7 @@ bool VirtualMemoryBlock::IsInMyRange(const u64 addr, const u32 size)
 
 bool VirtualMemoryBlock::IsMyAddress(const u64 addr)
 {
-	for(u32 i=0; i<m_mapped_memory.GetCount(); ++i)
+	for(u32 i=0; i<m_mapped_memory.size(); ++i)
 	{
 		if(addr >= m_mapped_memory[i].addr && addr < m_mapped_memory[i].addr + m_mapped_memory[i].size)
 		{
@@ -577,7 +577,7 @@ u64 VirtualMemoryBlock::Map(u64 realaddr, u32 size, u64 addr)
 		if(!IsInMyRange(addr, size) && (IsMyAddress(addr) || IsMyAddress(addr + size - 1)))
 			return 0;
 
-		m_mapped_memory.Move(new VirtualMemInfo(addr, realaddr, size));
+		m_mapped_memory.emplace_back(addr, realaddr, size);
 		return addr;
 	}
 	else
@@ -587,7 +587,7 @@ u64 VirtualMemoryBlock::Map(u64 realaddr, u32 size, u64 addr)
 			bool is_good_addr = true;
 
 			// check if address is already mapped
-			for(u32 i=0; i<m_mapped_memory.GetCount(); ++i)
+			for(u32 i=0; i<m_mapped_memory.size(); ++i)
 			{
 				if((addr >= m_mapped_memory[i].addr && addr < m_mapped_memory[i].addr + m_mapped_memory[i].size) ||
 					(m_mapped_memory[i].addr >= addr && m_mapped_memory[i].addr < addr + size))
@@ -600,7 +600,7 @@ u64 VirtualMemoryBlock::Map(u64 realaddr, u32 size, u64 addr)
 
 			if(!is_good_addr) continue;
 
-			m_mapped_memory.Move(new VirtualMemInfo(addr, realaddr, size));
+			m_mapped_memory.emplace_back(addr, realaddr, size);
 
 			return addr;
 		}
@@ -611,12 +611,12 @@ u64 VirtualMemoryBlock::Map(u64 realaddr, u32 size, u64 addr)
 
 u32 VirtualMemoryBlock::UnmapRealAddress(u64 realaddr)
 {
-	for(u32 i=0; i<m_mapped_memory.GetCount(); ++i)
+	for(u32 i=0; i<m_mapped_memory.size(); ++i)
 	{
 		if(m_mapped_memory[i].realAddress == realaddr && IsInMyRange(m_mapped_memory[i].addr, m_mapped_memory[i].size))
 		{
 			u32 size = m_mapped_memory[i].size;
-			m_mapped_memory.RemoveAt(i);
+			m_mapped_memory.erase(m_mapped_memory.begin() + i);
 			return size;
 		}
 	}
@@ -626,12 +626,12 @@ u32 VirtualMemoryBlock::UnmapRealAddress(u64 realaddr)
 
 u32 VirtualMemoryBlock::UnmapAddress(u64 addr)
 {
-	for(u32 i=0; i<m_mapped_memory.GetCount(); ++i)
+	for(u32 i=0; i<m_mapped_memory.size(); ++i)
 	{
 		if(m_mapped_memory[i].addr == addr && IsInMyRange(m_mapped_memory[i].addr, m_mapped_memory[i].size))
 		{
 			u32 size = m_mapped_memory[i].size;
-			m_mapped_memory.RemoveAt(i);
+			m_mapped_memory.erase(m_mapped_memory.begin() + i);
 			return size;
 		}
 	}
@@ -711,7 +711,7 @@ bool VirtualMemoryBlock::Write128(const u64 addr, const u128 value)
 
 u64 VirtualMemoryBlock::getRealAddr(u64 addr)
 {
-	for(u32 i=0; i<m_mapped_memory.GetCount(); ++i)
+	for(u32 i=0; i<m_mapped_memory.size(); ++i)
 	{
 		if(addr >= m_mapped_memory[i].addr && addr < m_mapped_memory[i].addr + m_mapped_memory[i].size)
 		{
@@ -724,7 +724,7 @@ u64 VirtualMemoryBlock::getRealAddr(u64 addr)
 
 u64 VirtualMemoryBlock::getMappedAddress(u64 realAddress)
 {
-	for(u32 i=0; i<m_mapped_memory.GetCount(); ++i)
+	for(u32 i=0; i<m_mapped_memory.size(); ++i)
 	{
 		if(realAddress >= m_mapped_memory[i].realAddress && realAddress < m_mapped_memory[i].realAddress + m_mapped_memory[i].size)
 		{
@@ -737,7 +737,7 @@ u64 VirtualMemoryBlock::getMappedAddress(u64 realAddress)
 
 void VirtualMemoryBlock::Delete()
 {
-	m_mapped_memory.Clear();
+	m_mapped_memory.clear();
 
 	MemoryBlock::Delete();
 }
@@ -763,4 +763,4 @@ bool VirtualMemoryBlock::Unreserve(u32 size)
 u32 VirtualMemoryBlock::GetResevedAmount()
 {
 	return m_reserve_size;
-}
\ No newline at end of file
+}
diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index e1535e8e82..7bb7729177 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -2,6 +2,8 @@
 #include "MemoryBlock.h"
 #include <vector>
 
+using std::nullptr_t;
+
 enum MemoryType
 {
 	Memory_PS3,
@@ -488,7 +490,8 @@ public:
 	u8* operator + (const u64 vaddr)
 	{
 		u8* ret = GetMemFromAddr(vaddr);
-		if(!ret) throw fmt::Format("GetMemFromAddr(0x%llx)", vaddr);
+		if(ret == nullptr)
+			throw fmt::Format("GetMemFromAddr(0x%x)", vaddr);
 		return ret;
 	}
 
diff --git a/rpcs3/Emu/Memory/MemoryBlock.h b/rpcs3/Emu/Memory/MemoryBlock.h
index 1e4bc16415..49446a2d86 100644
--- a/rpcs3/Emu/Memory/MemoryBlock.h
+++ b/rpcs3/Emu/Memory/MemoryBlock.h
@@ -20,7 +20,7 @@ struct MemInfo
 
 struct MemBlockInfo : public MemInfo
 {
-	void* mem;
+	void *mem;
 
 	MemBlockInfo(u64 _addr, u32 _size)
 		: MemInfo(_addr, PAGE_4K(_size))
@@ -31,13 +31,27 @@ struct MemBlockInfo : public MemInfo
 			ConLog.Error("Not enought free memory.");
 			assert(0);
 		}
-		
 		memset(mem, 0, size);
 	}
 
+	MemBlockInfo(MemBlockInfo &other) = delete;
+	MemBlockInfo(MemBlockInfo &&other) : MemInfo(other.addr,other.size) ,mem(other.mem)
+	{
+		other.mem = nullptr;
+	}
+	MemBlockInfo& operator =(MemBlockInfo &other) = delete;
+	MemBlockInfo& operator =(MemBlockInfo &&other){
+		this->addr = other.addr;
+		this->size = other.size;
+		if (this->mem) _aligned_free(mem);
+		this->mem = other.mem;
+		other.mem = nullptr;
+		return *this;
+	}
+
 	~MemBlockInfo()
 	{
-		_aligned_free(mem);
+		if(mem) _aligned_free(mem);
 		mem = nullptr;
 	}
 };
@@ -193,9 +207,9 @@ template<typename PT>
 class DynamicMemoryBlockBase : public PT
 {
 	mutable std::mutex m_lock;
-	Array<MemBlockInfo> m_allocated; // allocation info
-	Array<u8*> m_pages; // real addresses of every 4096 byte pages (array size should be fixed)
-	Array<u8*> m_locked; // locked pages should be moved here
+	std::vector<MemBlockInfo> m_allocated; // allocation info
+	std::vector<u8*> m_pages; // real addresses of every 4096 byte pages (array size should be fixed)
+	std::vector<u8*> m_locked; // locked pages should be moved here
 	
 	u32 m_max_size;
 
@@ -229,7 +243,7 @@ private:
 
 class VirtualMemoryBlock : public MemoryBlock
 {
-	Array<VirtualMemInfo> m_mapped_memory;
+	std::vector<VirtualMemInfo> m_mapped_memory;
 	u32 m_reserve_size;
 
 public:
@@ -283,3 +297,4 @@ public:
 
 typedef DynamicMemoryBlockBase<MemoryBlock> DynamicMemoryBlock;
 typedef DynamicMemoryBlockBase<MemoryBlockLE> DynamicMemoryBlockLE;
+
diff --git a/rpcs3/Emu/SysCalls/Callback.h b/rpcs3/Emu/SysCalls/Callback.h
index a21709aee0..093fc13379 100644
--- a/rpcs3/Emu/SysCalls/Callback.h
+++ b/rpcs3/Emu/SysCalls/Callback.h
@@ -44,7 +44,7 @@ struct Callback3 : public Callback
 
 struct Callbacks
 {
-	Array<Callback> m_callbacks;
+	std::vector<Callback> m_callbacks;
 	bool m_in_manager;
 
 	Callbacks() : m_in_manager(false)
@@ -58,11 +58,11 @@ struct Callbacks
 
 	void Unregister(u32 slot)
 	{
-		for(u32 i=0; i<m_callbacks.GetCount(); ++i)
+		for(u32 i=0; i<m_callbacks.size(); ++i)
 		{
 			if(m_callbacks[i].GetSlot() == slot)
 			{
-				m_callbacks.RemoveAt(i);
+				m_callbacks.erase(m_callbacks.begin() + i);
 				break;
 			}
 		}
@@ -74,7 +74,7 @@ struct Callbacks
 	{
 		bool handled = false;
 
-		for(u32 i=0; i<m_callbacks.GetCount(); ++i)
+		for(u32 i=0; i<m_callbacks.size(); ++i)
 		{
 			if(m_callbacks[i].HasData())
 			{
@@ -96,12 +96,13 @@ struct Callbacks2 : public Callbacks
 	void Register(u32 slot, u64 addr, u64 userdata)
 	{
 		Callbacks::Register(slot, addr, userdata);
-		m_callbacks.Move(new Callback2(slot, addr, userdata));
+		Callback2 callback(slot, addr, userdata);
+		m_callbacks.push_back(callback);
 	}
 
 	void Handle(u64 a1, u64 a2)
 	{
-		for(u32 i=0; i<m_callbacks.GetCount(); ++i)
+		for(u32 i=0; i<m_callbacks.size(); ++i)
 		{
 			((Callback2&)m_callbacks[i]).Handle(a1);
 		}
@@ -117,12 +118,13 @@ struct Callbacks3 : public Callbacks
 	void Register(u32 slot, u64 addr, u64 userdata)
 	{
 		Callbacks::Register(slot, addr, userdata);
-		m_callbacks.Move(new Callback3(slot, addr, userdata));
+		Callback3 callback(slot, addr, userdata);
+		m_callbacks.push_back(callback);
 	}
 
 	void Handle(u64 a1, u64 a2)
 	{
-		for(u32 i=0; i<m_callbacks.GetCount(); ++i)
+		for(u32 i=0; i<m_callbacks.size(); ++i)
 		{
 			((Callback3&)m_callbacks[i]).Handle(a1, a2);
 		}
@@ -131,7 +133,7 @@ struct Callbacks3 : public Callbacks
 
 struct CallbackManager
 {
-	ArrayF<Callbacks> m_callbacks;
+	std::vector<Callbacks *> m_callbacks;
 	Callbacks3 m_exit_callback;
 
 	void Add(Callbacks& c)
@@ -139,7 +141,7 @@ struct CallbackManager
 		if(c.m_in_manager) return;
 
 		c.m_in_manager = true;
-		m_callbacks.Add(c);
+		m_callbacks.push_back(&c);
 	}
 
 	void Init()
@@ -149,12 +151,12 @@ struct CallbackManager
 
 	void Clear()
 	{
-		for(u32 i=0; i<m_callbacks.GetCount(); ++i)
+		for(u32 i=0; i<m_callbacks.size(); ++i)
 		{
-			m_callbacks[i].m_callbacks.Clear();
-			m_callbacks[i].m_in_manager = false;
+			m_callbacks[i]->m_callbacks.clear();
+			m_callbacks[i]->m_in_manager = false;
 		}
 
-		m_callbacks.ClearF();
+		m_callbacks.clear();
 	}
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/SysCalls/Modules.cpp b/rpcs3/Emu/SysCalls/Modules.cpp
index 6e2f6e2f93..b759960929 100644
--- a/rpcs3/Emu/SysCalls/Modules.cpp
+++ b/rpcs3/Emu/SysCalls/Modules.cpp
@@ -3,12 +3,13 @@
 #include "SC_FUNC.h"
 #include <mutex>
 
+
 Module* g_modules[3][0xff] = {0};
 uint g_max_module_id = 0;
 uint g_module_2_count = 0;
-ArrayF<ModuleFunc> g_modules_funcs_list;
+std::vector<ModuleFunc *> g_modules_funcs_list;
 std::mutex g_funcs_lock;
-ArrayF<SFunc> g_static_funcs_list;
+std::vector<SFunc *> g_static_funcs_list;
 
 struct ModuleInfo
 {
@@ -116,25 +117,50 @@ static const g_module_list[] =
 	{0xf034, "cellSailRec"},
 	{0xf035, "sceNpTrophy"},
 	{0xf053, "cellAdecAt3multi"},
-	{0xf054, "cellLibatrac3multi"},
+	{0xf054, "cellLibatrac3multi"}
 };
 
 struct _InitNullModules
 {
+	std::vector<Module*> m_modules;
+
 	_InitNullModules()
 	{
 		for(auto& m : g_module_list)
 		{
-			new Module(m.id, m.name);
+			m_modules.push_back(new Module(m.id, m.name));
+		}
+	}
+
+	~_InitNullModules()
+	{
+		for (int i = 0; i < m_modules.size(); ++i)
+		{
+			delete m_modules[i];
 		}
 	}
 } InitNullModules;
 
+/** HACK: Used to delete SFunc objects that get added to the global static function array (g_static_funcs_list).
+ * The destructor of this static object gets called when the program shuts down.
+ */
+struct StaticFunctionListCleaner_t
+{
+	StaticFunctionListCleaner_t() {}
+	~StaticFunctionListCleaner_t()
+	{
+		for (int i = 0; i < g_static_funcs_list.size(); ++i)
+		{
+			delete g_static_funcs_list[i];
+		}
+	}
+} StaticFunctionListCleaner;
+
 bool IsLoadedFunc(u32 id)
 {
-	for(u32 i=0; i<g_modules_funcs_list.GetCount(); ++i)
+	for(u32 i=0; i<g_modules_funcs_list.size(); ++i)
 	{
-		if(g_modules_funcs_list[i].id == id)
+		if(g_modules_funcs_list[i]->id == id)
 		{
 			return true;
 		}
@@ -149,11 +175,11 @@ bool CallFunc(u32 num)
 	{
 		std::lock_guard<std::mutex> lock(g_funcs_lock);
 
-		for(u32 i=0; i<g_modules_funcs_list.GetCount(); ++i)
+		for(u32 i=0; i<g_modules_funcs_list.size(); ++i)
 		{
-			if(g_modules_funcs_list[i].id == num)
+			if(g_modules_funcs_list[i]->id == num)
 			{
-				func = g_modules_funcs_list[i].func;
+				func = g_modules_funcs_list[i]->func;
 				break;
 			}
 		}
@@ -170,11 +196,11 @@ bool UnloadFunc(u32 id)
 {
 	std::lock_guard<std::mutex> lock(g_funcs_lock);
 
-	for(u32 i=0; i<g_modules_funcs_list.GetCount(); ++i)
+	for(u32 i=0; i<g_modules_funcs_list.size(); ++i)
 	{
-		if(g_modules_funcs_list[i].id == id)
+		if(g_modules_funcs_list[i]->id == id)
 		{
-			g_modules_funcs_list.RemoveFAt(i);
+			g_modules_funcs_list.erase(g_modules_funcs_list.begin() +i);
 
 			return true;
 		}
@@ -202,7 +228,7 @@ void UnloadModules()
 	}
 
 	std::lock_guard<std::mutex> lock(g_funcs_lock);
-	g_modules_funcs_list.Clear();
+	g_modules_funcs_list.clear();
 }
 
 Module* GetModuleByName(const std::string& name)
@@ -268,13 +294,13 @@ void SetModule(int id, Module* module, bool with_data)
 			if(with_data)
 			{
 				module->SetName(g_modules[index][(u8)id]->GetName());
-				delete g_modules[index][(u8)id];
+				// delete g_modules[index][(u8)id];
 				g_modules[index][(u8)id] = module;
 			}
 			else
 			{
 				g_modules[index][(u8)id]->SetName(module->GetName());
-				delete module;
+				// delete module;
 			}
 		}
 		else
@@ -324,6 +350,16 @@ Module::Module(u16 id, void (*init)(), void (*load)(), void (*unload)())
 	if(init) init();
 }
 
+Module::~Module()
+{
+	UnLoad();
+
+	for (int i = 0; i < m_funcs_list.size(); i++)
+	{
+		delete m_funcs_list[i];
+	}
+}
+
 void Module::Load()
 {
 	if(IsLoaded())
@@ -331,13 +367,13 @@ void Module::Load()
 
 	if(m_load_func) m_load_func();
 
-	for(u32 i=0; i<m_funcs_list.GetCount(); ++i)
+	for(u32 i=0; i<m_funcs_list.size(); ++i)
 	{
 		std::lock_guard<std::mutex> lock(g_funcs_lock);
 
-		if(IsLoadedFunc(m_funcs_list[i].id)) continue;
+		if(IsLoadedFunc(m_funcs_list[i]->id)) continue;
 		
-		g_modules_funcs_list.Add(m_funcs_list[i]);
+		g_modules_funcs_list.push_back(m_funcs_list[i]);
 	}
 
 	SetLoaded(true);
@@ -350,9 +386,9 @@ void Module::UnLoad()
 
 	if(m_unload_func) m_unload_func();
 
-	for(u32 i=0; i<m_funcs_list.GetCount(); ++i)
+	for(u32 i=0; i<m_funcs_list.size(); ++i)
 	{
-		UnloadFunc(m_funcs_list[i].id);
+		UnloadFunc(m_funcs_list[i]->id);
 	}
 
 	SetLoaded(false);
@@ -364,11 +400,11 @@ bool Module::Load(u32 id)
 
 	if(IsLoadedFunc(id)) return false;
 
-	for(u32 i=0; i<m_funcs_list.GetCount(); ++i)
+	for(u32 i=0; i<m_funcs_list.size(); ++i)
 	{
-		if(m_funcs_list[i].id == id)
+		if(m_funcs_list[i]->id == id)
 		{
-			g_modules_funcs_list.Add(m_funcs_list[i]);
+			g_modules_funcs_list.push_back(m_funcs_list[i]);
 
 			return true;
 		}
@@ -470,3 +506,4 @@ bool Module::CheckID(u32 id, ID*& _id) const
 {
 	return Emu.GetIdManager().CheckID(id) && (_id = &Emu.GetIdManager().GetID(id))->m_name == GetName();
 }
+
diff --git a/rpcs3/Emu/SysCalls/Modules.h b/rpcs3/Emu/SysCalls/Modules.h
index 71a8e4c13c..c940df2b58 100644
--- a/rpcs3/Emu/SysCalls/Modules.h
+++ b/rpcs3/Emu/SysCalls/Modules.h
@@ -1,16 +1,7 @@
 #pragma once
-#include "Modules/cellResc.h"
-#include "Modules/cellPngDec.h"
-#include "Modules/cellJpgDec.h"
-#include "Modules/cellGifDec.h"
 
 #define declCPU PPUThread& CPU = GetCurrentPPUThread
 
-class func_caller
-{
-public:
-	virtual void operator()() = 0;
-};
 
 //TODO
 struct ModuleFunc
@@ -23,6 +14,11 @@ struct ModuleFunc
 		, func(func)
 	{
 	}
+
+	~ModuleFunc()
+	{
+		safe_delete(func);
+	}
 };
 
 struct SFuncOp
@@ -36,12 +32,17 @@ struct SFunc
 	func_caller* func;
 	void* ptr;
 	char* name;
-	Array<SFuncOp> ops;
+	std::vector<SFuncOp> ops;
 	u64 group;
 	u32 found;
+
+	~SFunc()
+	{
+		safe_delete(func);
+	}
 };
 
-extern ArrayF<SFunc> g_static_funcs_list;
+extern std::vector<SFunc *> g_static_funcs_list;
 
 class Module
 {
@@ -52,12 +53,14 @@ class Module
 	void (*m_unload_func)();
 
 public:
-	Array<ModuleFunc> m_funcs_list;
+	std::vector<ModuleFunc*> m_funcs_list;
 
 	Module(u16 id, const char* name);
 	Module(const char* name, void (*init)(), void (*load)() = nullptr, void (*unload)() = nullptr);
 	Module(u16 id, void (*init)(), void (*load)() = nullptr, void (*unload)() = nullptr);
 
+	~Module();
+
 	void Load();
 	void UnLoad();
 	bool Load(u32 id);
@@ -120,7 +123,7 @@ public:
 template<typename T>
 __forceinline void Module::AddFunc(u32 id, T func)
 {
-	m_funcs_list.Move(new ModuleFunc(id, bind_func(func)));
+	m_funcs_list.emplace_back(new ModuleFunc(id, bind_func(func)));
 }
 
 template<typename T>
@@ -128,8 +131,9 @@ __forceinline void Module::AddFuncSub(const char group[8], const u64 ops[], char
 {
 	if (!ops[0]) return;
 
+	//TODO: track down where this is supposed to be deleted
 	SFunc* sf = new SFunc;
-	sf->ptr = func;
+	sf->ptr = (void *)func;
 	sf->func = bind_func(func);
 	sf->name = name;
 	sf->group = *(u64*)group;
@@ -145,9 +149,9 @@ __forceinline void Module::AddFuncSub(const char group[8], const u64 ops[], char
 		if (op.mask) op.crc &= op.mask;
 		op.mask = re(op.mask);
 		op.crc = re(op.crc);
-		sf->ops.AddCpy(op);
+		sf->ops.push_back(op);
 	}
-	g_static_funcs_list.Add(sf);
+	g_static_funcs_list.push_back(sf);
 }
 
 bool IsLoadedFunc(u32 id);
@@ -157,3 +161,4 @@ void UnloadModules();
 u32 GetFuncNumById(u32 id);
 Module* GetModuleByName(const std::string& name);
 Module* GetModuleById(u16 id);
+
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
index eeca7af654..a0418e3be5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
@@ -65,7 +65,7 @@ int cellAudioInit()
 			}
 			queue.Clear();
 
-			Array<u64> keys;
+			std::vector<u64> keys;
 
 			if(m_audio_out)
 			{
@@ -354,10 +354,10 @@ int cellAudioInit()
 						index = (position + 1) % port.block; // write new value
 					}
 					// load keys:
-					keys.SetCount(m_config.m_keys.GetCount());
-					memcpy(keys.GetPtr(), m_config.m_keys.GetPtr(), sizeof(u64) * keys.GetCount());
+					keys.resize(m_config.m_keys.size());
+					memcpy(keys.data(), m_config.m_keys.data(), sizeof(u64) * keys.size());
 				}
-				for (u32 i = 0; i < keys.GetCount(); i++)
+				for (u32 i = 0; i < keys.size(); i++)
 				{
 					// TODO: check event source
 					Emu.GetEventManager().SendEvent(keys[i], 0x10103000e010e07, 0, 0, 0);
@@ -402,7 +402,7 @@ abort:
 
 			m_config.m_is_audio_initialized = false;
 
-			m_config.m_keys.Clear();
+			m_config.m_keys.clear();
 			for (u32 i = 0; i < m_config.AUDIO_PORT_COUNT; i++)
 			{
 				AudioPortConfig& port = m_config.m_ports[i];
@@ -736,14 +736,14 @@ int cellAudioSetNotifyEventQueue(u64 key)
 
 	SMutexGeneralLocker lock(audioMutex);
 
-	for (u32 i = 0; i < m_config.m_keys.GetCount(); i++) // check for duplicates
+	for (u32 i = 0; i < m_config.m_keys.size(); i++) // check for duplicates
 	{
 		if (m_config.m_keys[i] == key)
 		{
 			return CELL_AUDIO_ERROR_PARAM;
 		}
 	}
-	m_config.m_keys.AddCpy(key);
+	m_config.m_keys.push_back(key);
 
 	/*EventQueue* eq;
 	if (!Emu.GetEventManager().GetEventQueue(key, eq))
@@ -769,11 +769,11 @@ int cellAudioRemoveNotifyEventQueue(u64 key)
 	SMutexGeneralLocker lock(audioMutex);
 
 	bool found = false;
-	for (u32 i = 0; i < m_config.m_keys.GetCount(); i++)
+	for (u32 i = 0; i < m_config.m_keys.size(); i++)
 	{
 		if (m_config.m_keys[i] == key)
 		{
-			m_config.m_keys.RemoveAt(i);
+			m_config.m_keys.erase(m_config.m_keys.begin() + i);
 			found = true;
 			break;
 		}
@@ -862,4 +862,4 @@ void cellAudio_init()
 	cellAudio.AddFunc(0xdab029aa, cellAudioAddData);
 	cellAudio.AddFunc(0xe4046afe, cellAudioGetPortBlockTag);
 	cellAudio.AddFunc(0xff3626fd, cellAudioRemoveNotifyEventQueue);
-}
\ No newline at end of file
+}
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
index b8a16cb664..3933f2d789 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
@@ -5,8 +5,9 @@
 #include "stblib/stb_truetype.h"
 
 void cellFont_init();
+void cellFont_load();
 void cellFont_unload();
-Module cellFont(0x0019, cellFont_init, nullptr, cellFont_unload);
+Module cellFont(0x0019, cellFont_init, cellFont_load, cellFont_unload);
 
 // Font Set Types
 enum
@@ -226,7 +227,7 @@ struct CCellFontInternal      //Module cellFont
 	}
 };
 
-CCellFontInternal* s_fontInternalInstance = new CCellFontInternal();
+CCellFontInternal* s_fontInternalInstance = nullptr;
 
 // Functions
 int cellFontInitializeWithRevision(u64 revisionFlags, mem_ptr_t<CellFontConfig> config)
@@ -899,8 +900,14 @@ void cellFont_init()
 	cellFont.AddFunc(0xb015a84e, cellFontGetRevisionFlags);
 }
 
+void cellFont_load()
+{
+	s_fontInternalInstance = new CCellFontInternal();
+}
+
 void cellFont_unload()
 {
-	s_fontInternalInstance->m_bInitialized = false;
-	s_fontInternalInstance->m_bFontGcmInitialized = false;
+	// s_fontInternalInstance->m_bInitialized = false;
+	// s_fontInternalInstance->m_bFontGcmInitialized = false;
+	delete s_fontInternalInstance;
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp b/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
index 9cc0210149..174e06e53d 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
@@ -4,7 +4,9 @@
 #include "cellFont.h"
 
 void cellFontFT_init();
-Module cellFontFT(0x001a, cellFontFT_init);
+void cellFontFT_load();
+void cellFontFT_unload();
+Module cellFontFT(0x001a, cellFontFT_init, cellFontFT_load, cellFontFT_unload);
 
 struct CellFontLibraryConfigFT
 {
@@ -33,7 +35,7 @@ struct CCellFontFTInternal
 	}
 };
 
-CCellFontFTInternal* s_fontFtInternalInstance = new CCellFontFTInternal();
+CCellFontFTInternal* s_fontFtInternalInstance = nullptr;
 
 int cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, mem_ptr_t<CellFontLibraryConfigFT> config, u32 lib_addr_addr)
 {
@@ -67,4 +69,14 @@ void cellFontFT_init()
 	cellFontFT.AddFunc(0x7a0a83c4, cellFontInitLibraryFreeTypeWithRevision);
 	cellFontFT.AddFunc(0xec89a187, cellFontFTGetRevisionFlags);
 	cellFontFT.AddFunc(0xfa0c2de0, cellFontFTGetInitializedRevisionFlags);
+}
+
+void cellFontFT_load()
+{
+	s_fontFtInternalInstance = new CCellFontFTInternal();
+}
+
+void cellFontFT_unload()
+{
+	delete s_fontFtInternalInstance;
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index 530a074f29..6eb58a61bb 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -164,7 +164,11 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 
 	//Decode PNG file. (TODO: Is there any faster alternative? Can we do it without external libraries?)
 	int width, height, actual_components;
-	std::shared_ptr<unsigned char> image(stbi_load_from_memory(png.GetPtr(), fileSize, &width, &height, &actual_components, 4));
+	auto image = std::unique_ptr<unsigned char,decltype(&::free)>
+			(
+				stbi_load_from_memory(png.GetPtr(), fileSize, &width, &height, &actual_components, 4),
+				&::free
+			);
 	if (!image)	return CELL_PNGDEC_ERROR_STREAM_FORMAT;
 
 	uint image_size = width * height;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
index 790053ff67..3b419e9799 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
@@ -5,8 +5,9 @@
 #include "cellResc.h"
 
 void cellResc_init();
+void cellResc_load();
 void cellResc_unload();
-Module cellResc(0x001f, cellResc_init, nullptr, cellResc_unload);
+Module cellResc(0x001f, cellResc_init, cellResc_load, cellResc_unload);
 
 // Error Codes
 enum
@@ -71,7 +72,7 @@ struct CCellRescInternal
 };
 
 
-CCellRescInternal* s_rescInternalInstance = new CCellRescInternal();
+CCellRescInternal* s_rescInternalInstance = nullptr;
 
 // Extern Functions
 extern int cellGcmSetFlipMode(u32 mode);
@@ -810,7 +811,13 @@ void cellResc_init()
 	//cellResc.AddFunc(0xe0cef79e, cellRescCreateInterlaceTable);
 }
 
+void cellResc_load()
+{
+	s_rescInternalInstance = new CCellRescInternal();
+}
+
 void cellResc_unload()
 {
-	s_rescInternalInstance->m_bInitialized = false;
+	// s_rescInternalInstance->m_bInitialized = false;
+	delete s_rescInternalInstance;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp b/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
index 3c0a541d56..088eaa1d1c 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
@@ -30,6 +30,7 @@ int cellUserInfoGetStat(u32 id, mem_ptr_t<CellUserInfoUserStat> stat)
 	memset(name, 0, CELL_USERINFO_USERNAME_SIZE);
 	stream->Read(name, CELL_USERINFO_USERNAME_SIZE);
 	stream->Close();
+	delete stream;
 
 	stat->id = id;
 	memcpy(stat->name, name, CELL_USERINFO_USERNAME_SIZE);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
index 32581f3567..692fa43772 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
@@ -803,4 +803,4 @@ void cellVdec_init()
 
 	av_register_all();
 	avcodec_register_all();
-}
\ No newline at end of file
+}
diff --git a/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp b/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
index 557148cf61..84c2e410e3 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
@@ -97,7 +97,7 @@ int cellVpostExec(u32 handle, const u32 inPicBuff_addr, const mem_ptr_t<CellVpos
 		return CELL_VPOST_ERROR_E_ARG_CTRL_INVALID;
 	}
 
-	u32 w = ctrlParam->inWidth;
+	s32 w = ctrlParam->inWidth;
 	u32 h = ctrlParam->inHeight;
 	u32 ow = ctrlParam->outWidth;
 	u32 oh = ctrlParam->outHeight;
@@ -193,7 +193,7 @@ int cellVpostExec(u32 handle, const u32 inPicBuff_addr, const mem_ptr_t<CellVpos
 	u8* in_data[4] = { pY, pU, pV, pA };
 	int in_line[4] = { w, w/2, w/2, w };
 	u8* out_data[4] = { (u8*)res, NULL, NULL, NULL };
-	int out_line[4] = { ow*4, 0, 0, 0 };
+	int out_line[4] = { static_cast<int>(ow*4), 0, 0, 0 };
 
 	sws_scale(sws, in_data, in_line, 0, h, out_data, out_line);
 
@@ -225,4 +225,4 @@ void cellVpost_init()
 	cellVpost.AddFunc(0x40524325, cellVpostOpenEx);
 	cellVpost.AddFunc(0x10ef39f6, cellVpostClose);
 	cellVpost.AddFunc(0xabb8cc3d, cellVpostExec);
-}
\ No newline at end of file
+}
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNp.cpp b/rpcs3/Emu/SysCalls/Modules/sceNp.cpp
index ec37e7592b..a49aeba4b8 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNp.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNp.cpp
@@ -51,12 +51,12 @@ int sceNpDrmIsAvailable(u32 k_licensee_addr, u32 drm_path_addr)
 		sceNp.Warning("sceNpDrmIsAvailable: Can't find RAP file for DRM!");
 	else
 	{
-		Array<DirEntryInfo> entries = raps_dir->GetEntries();
-		for (unsigned int i = 0; i < entries.GetCount(); i++)
+		const std::vector<DirEntryInfo> &entries = raps_dir->GetEntries();
+		for (auto &entry:  entries)
 		{
-			if (entries[i].name.find(fmt::ToUTF8(titleID)) != std::string::npos )
+			if (entry.name.find(fmt::ToUTF8(titleID)) != std::string::npos )
 			{
-				rap_file_path += fmt::FromUTF8(entries[i].name);
+				rap_file_path += fmt::FromUTF8(entry.name);
 				break;
 			}
 		}
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
index 77a71f81c7..c82b257c12 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
@@ -24,6 +24,18 @@ struct sceNpTrophyInternalContext
 	vfsStream* trp_stream;
 
 	TROPUSRLoader* tropusr;
+
+	sceNpTrophyInternalContext()
+		: trp_stream(nullptr),
+		tropusr(nullptr)
+	{
+	}
+
+	~sceNpTrophyInternalContext()
+	{
+		safe_delete(trp_stream);
+		safe_delete(tropusr);
+	}
 };
 
 struct sceNpTrophyInternal
@@ -132,8 +144,10 @@ int sceNpTrophyRegisterContext(u32 context, u32 handle, u32 statusCb_addr, u32 a
 		return SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE;
 
 	// Rename or discard certain entries based on the files found
-	char target [32];
-	sprintf(target, "TROP_%02d.SFM", Ini.SysLanguage.GetValue());
+	const size_t kTargetBufferLength = 31;
+	char target[kTargetBufferLength+1];
+	target[kTargetBufferLength] = 0;
+	snprintf(target, kTargetBufferLength, "TROP_%02d.SFM", Ini.SysLanguage.GetValue());
 
 	if (trp.ContainsEntry(target)) {
 		trp.RemoveEntry("TROPCONF.SFM");
@@ -150,7 +164,7 @@ int sceNpTrophyRegisterContext(u32 context, u32 handle, u32 statusCb_addr, u32 a
 
 	// Discard unnecessary TROP_XX.SFM files
 	for (int i=0; i<=18; i++) {
-		sprintf(target, "TROP_%02d.SFM", i);
+		snprintf(target, kTargetBufferLength, "TROP_%02d.SFM", i);
 		if (i != Ini.SysLanguage.GetValue())
 			trp.RemoveEntry(target);
 	}
@@ -288,7 +302,7 @@ int sceNpTrophyUnlockTrophy(u32 context, u32 handle, s32 trophyId, mem32_t plati
 	// TODO: There are other possible errors
 
 	sceNpTrophyInternalContext& ctxt = s_npTrophyInstance.contexts[context];
-	if (trophyId >= ctxt.tropusr->GetTrophiesCount())
+	if (trophyId >= (s32)ctxt.tropusr->GetTrophiesCount())
 		return SCE_NP_TROPHY_ERROR_INVALID_TROPHY_ID;
 	if (ctxt.tropusr->GetTrophyUnlockState(trophyId))
 		return SCE_NP_TROPHY_ERROR_ALREADY_UNLOCKED;
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
index 754d7e49eb..03f2c3ba30 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
@@ -80,7 +80,11 @@ s32 getLastError()
 	return errno;
 #endif
 }
-
+#ifdef _WIN32
+using pck_len_t = s32;
+#else
+using pck_len_t = u32;
+#endif
 
 // Functions
 int sys_net_accept(s32 s, mem_ptr_t<sys_net_sockaddr> addr, mem32_t paddrlen)
@@ -89,7 +93,7 @@ int sys_net_accept(s32 s, mem_ptr_t<sys_net_sockaddr> addr, mem32_t paddrlen)
 	sockaddr _addr;
 	memcpy(&_addr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr));
 	_addr.sa_family = addr->sa_family;
-	s32 *_paddrlen = (s32 *)Memory.VirtualToRealAddr(paddrlen.GetAddr());
+	pck_len_t *_paddrlen = (pck_len_t *) Memory.VirtualToRealAddr(paddrlen.GetAddr());
 	int ret = accept(s, &_addr, _paddrlen);
 	g_lastError = getLastError();
 	return ret;
@@ -227,7 +231,7 @@ int sys_net_recvfrom(s32 s, u32 buf_addr, u32 len, s32 flags, mem_ptr_t<sys_net_
 	sockaddr _addr;
 	memcpy(&_addr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr));
 	_addr.sa_family = addr->sa_family;
-	s32 *_paddrlen = (s32 *)Memory.VirtualToRealAddr(paddrlen.GetAddr());
+	pck_len_t *_paddrlen = (pck_len_t *) Memory.VirtualToRealAddr(paddrlen.GetAddr());
 	int ret = recvfrom(s, _buf_addr, len, flags, &_addr, _paddrlen);
 	g_lastError = getLastError();
 	return ret;
diff --git a/rpcs3/Emu/SysCalls/SC_FUNC.h b/rpcs3/Emu/SysCalls/SC_FUNC.h
index c77c80af7b..c03ed9ec76 100644
--- a/rpcs3/Emu/SysCalls/SC_FUNC.h
+++ b/rpcs3/Emu/SysCalls/SC_FUNC.h
@@ -1,8 +1,14 @@
 #pragma once
-#include "Modules.h"
 
 #define RESULT(x) SC_ARGS_1 = (x)
 
+class func_caller
+{
+public:
+	virtual void operator()() = 0;
+};
+
+
 template<bool is_in_sp, bool is_fp, bool is_ptr, typename T, int i>
 struct get_arg;
 
diff --git a/rpcs3/Emu/SysCalls/Static.cpp b/rpcs3/Emu/SysCalls/Static.cpp
index b635da2660..17ff68f413 100644
--- a/rpcs3/Emu/SysCalls/Static.cpp
+++ b/rpcs3/Emu/SysCalls/Static.cpp
@@ -3,7 +3,7 @@
 #include "Emu/SysCalls/SysCalls.h"
 #include "Emu/SysCalls/SC_FUNC.h"
 
-extern ArrayF<SFunc> g_static_funcs_list;
+extern std::vector<SFunc*> g_static_funcs_list;
 
 void StaticAnalyse(void* ptr, u32 size, u32 base)
 {
@@ -15,13 +15,13 @@ void StaticAnalyse(void* ptr, u32 size, u32 base)
 	// TODO: optimize search
 	for (u32 i = 0; i < size; i++)
 	{
-		for (u32 j = 0; j < g_static_funcs_list.GetCount(); j++)
+		for (u32 j = 0; j < g_static_funcs_list.size(); j++)
 		{
-			if ((data[i] & g_static_funcs_list[j].ops[0].mask) == g_static_funcs_list[j].ops[0].crc)
+			if ((data[i] & g_static_funcs_list[j]->ops[0].mask) == g_static_funcs_list[j]->ops[0].crc)
 			{
 				bool found = true;
 				u32 can_skip = 0;
-				for (u32 k = i, x = 0; x + 1 <= g_static_funcs_list[j].ops.GetCount(); k++, x++)
+				for (u32 k = i, x = 0; x + 1 <= g_static_funcs_list[j]->ops.size(); k++, x++)
 				{
 					if (k >= size)
 					{
@@ -36,8 +36,8 @@ void StaticAnalyse(void* ptr, u32 size, u32 base)
 						continue;
 					}
 
-					const u32 mask = g_static_funcs_list[j].ops[x].mask;
-					const u32 crc = g_static_funcs_list[j].ops[x].crc;
+					const u32 mask = g_static_funcs_list[j]->ops[x].mask;
+					const u32 crc = g_static_funcs_list[j]->ops[x].crc;
 
 					if (!mask)
 					{
@@ -83,8 +83,8 @@ void StaticAnalyse(void* ptr, u32 size, u32 base)
 				}
 				if (found)
 				{
-					ConLog.Write("Function '%s' hooked (addr=0x%x)", g_static_funcs_list[j].name, i * 4 + base);
-					g_static_funcs_list[j].found++;
+					ConLog.Write("Function '%s' hooked (addr=0x%x)", g_static_funcs_list[j]->name, i * 4 + base);
+					g_static_funcs_list[j]->found++;
 					data[i+0] = re32(0x39600000 | j); // li r11, j
 					data[i+1] = se32(0x44000003); // sc 3
 					data[i+2] = se32(0x4e800020); // blr
@@ -95,11 +95,11 @@ void StaticAnalyse(void* ptr, u32 size, u32 base)
 	}
 
 	// check function groups
-	for (u32 i = 0; i < g_static_funcs_list.GetCount(); i++)
+	for (u32 i = 0; i < g_static_funcs_list.size(); i++)
 	{
-		if (g_static_funcs_list[i].found) // start from some group
+		if (g_static_funcs_list[i]->found) // start from some group
 		{
-			const u64 group = g_static_funcs_list[i].group;
+			const u64 group = g_static_funcs_list[i]->group;
 
 			enum GroupSearchResult : u32
 			{
@@ -110,24 +110,24 @@ void StaticAnalyse(void* ptr, u32 size, u32 base)
 			u32 res = GSR_SUCCESS;
 
 			// analyse
-			for (u32 j = 0; j < g_static_funcs_list.GetCount(); j++) if (g_static_funcs_list[j].group == group)
+			for (u32 j = 0; j < g_static_funcs_list.size(); j++) if (g_static_funcs_list[j]->group == group)
 			{
-				u32 count = g_static_funcs_list[j].found;
+				u32 count = g_static_funcs_list[j]->found;
 
 				if (count == 0) // not found
 				{
 					// check if this function has been found with different pattern
-					for (u32 k = 0; k < g_static_funcs_list.GetCount(); k++) if (g_static_funcs_list[k].group == group)
+					for (u32 k = 0; k < g_static_funcs_list.size(); k++) if (g_static_funcs_list[k]->group == group)
 					{
-						if (k != j && g_static_funcs_list[k].ptr == g_static_funcs_list[j].ptr)
+						if (k != j && g_static_funcs_list[k]->ptr == g_static_funcs_list[j]->ptr)
 						{
-							count += g_static_funcs_list[k].found;
+							count += g_static_funcs_list[k]->found;
 						}
 					}
 					if (count == 0)
 					{
 						res |= GSR_MISSING;
-						ConLog.Error("Function '%s' not found", g_static_funcs_list[j].name);
+						ConLog.Error("Function '%s' not found", g_static_funcs_list[j]->name);
 					}
 					else if (count > 1)
 					{
@@ -137,14 +137,14 @@ void StaticAnalyse(void* ptr, u32 size, u32 base)
 				else if (count == 1) // found
 				{
 					// ensure that this function has NOT been found with different pattern
-					for (u32 k = 0; k < g_static_funcs_list.GetCount(); k++) if (g_static_funcs_list[k].group == group)
+					for (u32 k = 0; k < g_static_funcs_list.size(); k++) if (g_static_funcs_list[k]->group == group)
 					{
-						if (k != j && g_static_funcs_list[k].ptr == g_static_funcs_list[j].ptr)
+						if (k != j && g_static_funcs_list[k]->ptr == g_static_funcs_list[j]->ptr)
 						{
-							if (g_static_funcs_list[k].found)
+							if (g_static_funcs_list[k]->found)
 							{
 								res |= GSR_EXCESS;
-								ConLog.Error("Function '%s' hooked twice", g_static_funcs_list[j].name);
+								ConLog.Error("Function '%s' hooked twice", g_static_funcs_list[j]->name);
 							}
 						}
 					}
@@ -152,14 +152,14 @@ void StaticAnalyse(void* ptr, u32 size, u32 base)
 				else
 				{
 					res |= GSR_EXCESS;
-					ConLog.Error("Function '%s' hooked twice", g_static_funcs_list[j].name);
+					ConLog.Error("Function '%s' hooked twice", g_static_funcs_list[j]->name);
 				}
 			}
 
 			// clear data
-			for (u32 j = 0; j < g_static_funcs_list.GetCount(); j++)
+			for (u32 j = 0; j < g_static_funcs_list.size(); j++)
 			{
-				if (g_static_funcs_list[j].group == group) g_static_funcs_list[j].found = 0;
+				if (g_static_funcs_list[j]->group == group) g_static_funcs_list[j]->found = 0;
 			}
 
 			char name[9] = "????????";
@@ -182,9 +182,9 @@ void StaticAnalyse(void* ptr, u32 size, u32 base)
 
 void StaticExecute(u32 code)
 {
-	if (code < g_static_funcs_list.GetCount())
+	if (code < g_static_funcs_list.size())
 	{
-		(*g_static_funcs_list[code].func)();
+		(*g_static_funcs_list[code]->func)();
 	}
 	else
 	{
@@ -194,5 +194,5 @@ void StaticExecute(u32 code)
 
 void StaticFinalize()
 {
-	g_static_funcs_list.Clear();
-}
\ No newline at end of file
+	g_static_funcs_list.clear();
+}
diff --git a/rpcs3/Emu/SysCalls/SysCalls.cpp b/rpcs3/Emu/SysCalls/SysCalls.cpp
index 958b69a7f3..a068fbab8b 100644
--- a/rpcs3/Emu/SysCalls/SysCalls.cpp
+++ b/rpcs3/Emu/SysCalls/SysCalls.cpp
@@ -13,7 +13,9 @@ namespace detail{
 void default_syscall();
 static func_caller *null_func = bind_func(default_syscall);
 
-static func_caller* sc_table[1024] = 
+static const int kSyscallTableLength = 1024;
+
+static func_caller* sc_table[kSyscallTableLength] =
 {
 	null_func,
 	bind_func(sys_process_getpid),                          //1   (0x001)
@@ -502,6 +504,24 @@ static func_caller* sc_table[1024] =
 	null_func, null_func, null_func, bind_func(cellGcmCallback), //1024
 };
 
+/** HACK: Used to delete func_caller objects that get allocated and stored in sc_table (above).
+* The destructor of this static object gets called when the program shuts down.
+*/
+struct SyscallTableCleaner_t
+{
+	SyscallTableCleaner_t() {}
+	~SyscallTableCleaner_t()
+	{
+		for (int i = 0; i < kSyscallTableLength; ++i)
+		{
+			if (sc_table[i] != null_func)
+				delete sc_table[i];
+		}
+
+		delete null_func;
+	}
+} SyscallTableCleaner_t;
+
 void default_syscall()
 {
 	declCPU();
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Event.cpp b/rpcs3/Emu/SysCalls/lv2/SC_Event.cpp
index 246d597e88..26b4da0617 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_Event.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/SC_Event.cpp
@@ -77,7 +77,7 @@ int sys_event_queue_destroy(u32 equeue_id, int mode)
 	eq->sq.m_mutex.lock();
 	eq->owner.lock(tid);
 	// check if some threads are waiting for an event
-	if (!mode && eq->sq.list.GetCount())
+	if (!mode && eq->sq.list.size())
 	{
 		eq->owner.unlock(tid);
 		eq->sq.m_mutex.unlock();
@@ -85,7 +85,7 @@ int sys_event_queue_destroy(u32 equeue_id, int mode)
 	}
 	eq->owner.unlock(tid, ~0);
 	eq->sq.m_mutex.unlock();
-	while (eq->sq.list.GetCount())
+	while (eq->sq.list.size())
 	{
 		Sleep(1);
 		if (Emu.IsStopped())
@@ -138,7 +138,7 @@ int sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_ar
 
 	eq->sq.m_mutex.lock();
 	eq->owner.lock(tid);
-	if (eq->sq.list.GetCount())
+	if (eq->sq.list.size())
 	{
 		number = 0;
 		eq->owner.unlock(tid);
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Event_flag.cpp b/rpcs3/Emu/SysCalls/lv2/SC_Event_flag.cpp
index 4caf1c1d6f..577b0b3369 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_Event_flag.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/SC_Event_flag.cpp
@@ -50,7 +50,7 @@ int sys_event_flag_destroy(u32 eflag_id)
 	EventFlag* ef;
 	if(!sys_event_flag.CheckId(eflag_id, ef)) return CELL_ESRCH;
 
-	if (ef->waiters.GetCount()) // ???
+	if (ef->waiters.size()) // ???
 	{
 		return CELL_EBUSY;
 	}
@@ -89,7 +89,7 @@ int sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64
 
 	{
 		SMutexLocker lock(ef->m_mutex);
-		if (ef->m_type == SYS_SYNC_WAITER_SINGLE && ef->waiters.GetCount() > 0)
+		if (ef->m_type == SYS_SYNC_WAITER_SINGLE && ef->waiters.size() > 0)
 		{
 			return CELL_EPERM;
 		}
@@ -97,13 +97,13 @@ int sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64
 		rec.bitptn = bitptn;
 		rec.mode = mode;
 		rec.tid = tid;
-		ef->waiters.AddCpy(rec);
+		ef->waiters.push_back(rec);
 
 		if (ef->check() == tid)
 		{
 			u64 flags = ef->flags;
 
-			ef->waiters.RemoveAt(ef->waiters.GetCount() - 1);
+			ef->waiters.erase(ef->waiters.end() - 1);
 
 			if (mode & SYS_EVENT_FLAG_WAIT_CLEAR)
 			{
@@ -141,11 +141,11 @@ int sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64
 
 			u64 flags = ef->flags;
 
-			for (u32 i = 0; i < ef->waiters.GetCount(); i++)
+			for (u32 i = 0; i < ef->waiters.size(); i++)
 			{
 				if (ef->waiters[i].tid == tid)
 				{
-					ef->waiters.RemoveAt(i);
+					ef->waiters.erase(ef->waiters.begin() +i);
 
 					if (mode & SYS_EVENT_FLAG_WAIT_CLEAR)
 					{
@@ -179,11 +179,11 @@ int sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64
 		{
 			SMutexLocker lock(ef->m_mutex);
 
-			for (u32 i = 0; i < ef->waiters.GetCount(); i++)
+			for (u32 i = 0; i < ef->waiters.size(); i++)
 			{
 				if (ef->waiters[i].tid == tid)
 				{
-					ef->waiters.RemoveAt(i);
+					ef->waiters.erase(ef->waiters.begin() + i);
 					break;
 				}
 			}
@@ -300,19 +300,19 @@ int sys_event_flag_cancel(u32 eflag_id, mem32_t num)
 	EventFlag* ef;
 	if(!sys_event_flag.CheckId(eflag_id, ef)) return CELL_ESRCH;
 
-	Array<u32> tids;
+	std::vector<u32> tids;
 
 	{
 		SMutexLocker lock(ef->m_mutex);
-		tids.SetCount(ef->waiters.GetCount());
-		for (u32 i = 0; i < ef->waiters.GetCount(); i++)
+		tids.resize(ef->waiters.size());
+		for (u32 i = 0; i < ef->waiters.size(); i++)
 		{
 			tids[i] = ef->waiters[i].tid;
 		}
-		ef->waiters.Clear();
+		ef->waiters.clear();
 	}
 
-	for (u32 i = 0; i < tids.GetCount(); i++)
+	for (u32 i = 0; i < tids.size(); i++)
 	{
 		if (Emu.IsStopped()) break;
 		ef->signal.lock(tids[i]);
@@ -326,7 +326,7 @@ int sys_event_flag_cancel(u32 eflag_id, mem32_t num)
 
 	if (num.IsGood())
 	{
-		num = tids.GetCount();
+		num = tids.size();
 		return CELL_OK;
 	}
 
@@ -352,4 +352,4 @@ int sys_event_flag_get(u32 eflag_id, mem64_t flags)
 	flags = ef->flags; // ???
 
 	return CELL_OK;
-}
\ No newline at end of file
+}
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Event_flag.h b/rpcs3/Emu/SysCalls/lv2/SC_Event_flag.h
index 97209f335a..4cc1539d8d 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_Event_flag.h
+++ b/rpcs3/Emu/SysCalls/lv2/SC_Event_flag.h
@@ -33,7 +33,7 @@ struct EventFlag
 {
 	SMutex m_mutex;
 	u64 flags;
-	Array<EventFlagWaiter> waiters;
+	std::vector<EventFlagWaiter> waiters;
 	SMutex signal;
 	const u32 m_protocol;
 	const int m_type;
@@ -51,7 +51,7 @@ struct EventFlag
 
 		u32 target = 0;
 
-		for (u32 i = 0; i < waiters.GetCount(); i++)
+		for (u32 i = 0; i < waiters.size(); i++)
 		{
 			if (((waiters[i].mode & SYS_EVENT_FLAG_WAIT_AND) && (flags & waiters[i].bitptn) == waiters[i].bitptn) ||
 				((waiters[i].mode & SYS_EVENT_FLAG_WAIT_OR) && (flags & waiters[i].bitptn)))
@@ -61,7 +61,7 @@ struct EventFlag
 					target = waiters[i].tid;
 					break;
 				}
-				sq.list.AddCpy(waiters[i].tid);
+				sq.list.push_back(waiters[i].tid);
 			}
 		}
 
@@ -72,4 +72,4 @@ struct EventFlag
 
 		return target;
 	}
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp b/rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp
index 52af35a547..a706c4700a 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp
@@ -94,7 +94,8 @@ int cellFsOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
 		{
 			_oflags &= ~CELL_O_TRUNC;
 			//truncate file before opening it as read/write
-			Emu.GetVFS().OpenFile(ppath, vfsWrite);
+			auto filePtr = Emu.GetVFS().OpenFile(ppath, vfsWrite);
+			delete filePtr;
 		}
 		o_mode = vfsReadWrite;
 	break;
@@ -110,6 +111,7 @@ int cellFsOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
 
 	if(!stream || !stream->IsOpened())
 	{
+		delete stream;
 		sys_fs.Error("\"%s\" not found! flags: 0x%08x", ppath.c_str(), flags);
 		return CELL_ENOENT;
 	}
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Lwcond.cpp b/rpcs3/Emu/SysCalls/lv2/SC_Lwcond.cpp
index 6954c45158..5677f5b75f 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_Lwcond.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/SC_Lwcond.cpp
@@ -228,11 +228,11 @@ int sys_lwcond_wait(mem_ptr_t<sys_lwcond_t> lwcond, u64 timeout)
 			switch (mutex->lock(tid, 0))
 			{
 			case CELL_OK: break;
-			case CELL_EDEADLK: sys_lwcond.Warning("sys_lwcond_wait(id=%d): associated mutex was locked",
+			case static_cast<int>(CELL_EDEADLK): sys_lwcond.Warning("sys_lwcond_wait(id=%d): associated mutex was locked",
 								   (u32)lwcond->lwcond_queue); return CELL_OK;
-			case CELL_ESRCH: sys_lwcond.Warning("sys_lwcond_wait(id=%d): associated mutex not found (%d)",
+			case static_cast<int>(CELL_ESRCH): sys_lwcond.Warning("sys_lwcond_wait(id=%d): associated mutex not found (%d)",
 								 (u32)lwcond->lwcond_queue, (u32)mutex->sleep_queue); return CELL_ESRCH;
-			case CELL_EINVAL: goto abort;
+			case static_cast<int>(CELL_EINVAL): goto abort;
 			}
 
 			mutex->recursive_count = 1;
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Lwmutex.cpp b/rpcs3/Emu/SysCalls/lv2/SC_Lwmutex.cpp
index 4b0d480395..78d8372765 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_Lwmutex.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/SC_Lwmutex.cpp
@@ -100,7 +100,7 @@ int sys_lwmutex_unlock(mem_ptr_t<sys_lwmutex_t> lwmutex)
 void SleepQueue::push(u32 tid)
 {
 	std::lock_guard<std::mutex> lock(m_mutex);
-	list.AddCpy(tid);
+	list.push_back(tid);
 }
 
 u32 SleepQueue::pop() // SYS_SYNC_FIFO
@@ -109,10 +109,10 @@ u32 SleepQueue::pop() // SYS_SYNC_FIFO
 		
 	while (true)
 	{
-		if (list.GetCount())
+		if (list.size())
 		{
 			u32 res = list[0];
-			list.RemoveAt(0);
+			list.erase(list.begin());
 			if (res && Emu.GetIdManager().CheckID(res))
 			// check thread
 			{
@@ -129,11 +129,11 @@ u32 SleepQueue::pop_prio() // SYS_SYNC_PRIORITY
 
 	while (true)
 	{
-		if (list.GetCount())
+		if (list.size())
 		{
 			u32 highest_prio = ~0;
 			u32 sel = 0;
-			for (u32 i = 0; i < list.GetCount(); i++)
+			for (u32 i = 0; i < list.size(); i++)
 			{
 				CPUThread* t = Emu.GetCPU().GetThread(list[i]);
 				if (!t)
@@ -150,7 +150,7 @@ u32 SleepQueue::pop_prio() // SYS_SYNC_PRIORITY
 				}
 			}
 			u32 res = list[sel];
-			list.RemoveAt(sel);
+			list.erase(list.begin() + sel);
 			/* if (Emu.GetIdManager().CheckID(res)) */
 			if (res)
 			// check thread
@@ -173,11 +173,11 @@ bool SleepQueue::invalidate(u32 tid)
 {
 	std::lock_guard<std::mutex> lock(m_mutex);
 
-	if (tid) for (u32 i = 0; i < list.GetCount(); i++)
+	if (tid) for (u32 i = 0; i < list.size(); i++)
 	{
 		if (list[i] == tid)
 		{
-			list.RemoveAt(i);
+			list.erase(list.begin() + i);
 			return true;
 		}
 	}
@@ -189,7 +189,7 @@ bool SleepQueue::finalize()
 {
 	if (!m_mutex.try_lock()) return false;
 
-	for (u32 i = 0; i < list.GetCount(); i++)
+	for (u32 i = 0; i < list.size(); i++)
 	{
 		if (list[i])
 		{
@@ -299,7 +299,7 @@ int sys_lwmutex_t::lock(be_t<u32> tid, u64 timeout)
 {
 	switch (int res = trylock(tid))
 	{
-	case CELL_EBUSY: break;
+	case static_cast<int>(CELL_EBUSY): break;
 	default: return res;
 	}
 
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Lwmutex.h b/rpcs3/Emu/SysCalls/lv2/SC_Lwmutex.h
index 2fa724b52d..1239593bee 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_Lwmutex.h
+++ b/rpcs3/Emu/SysCalls/lv2/SC_Lwmutex.h
@@ -46,7 +46,7 @@ struct SleepQueue
 		u64 prio;
 		q_rec(u32 tid, u64 prio): tid(tid), prio(prio) {}
 	}; */
-	Array<u32> list;
+	std::vector<u32> list;
 	std::mutex m_mutex;
 	u64 m_name;
 
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Mutex.h b/rpcs3/Emu/SysCalls/lv2/SC_Mutex.h
index 735f20a240..0c30fe3e66 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_Mutex.h
+++ b/rpcs3/Emu/SysCalls/lv2/SC_Mutex.h
@@ -44,11 +44,11 @@ struct Mutex
 
 		if (!m_queue.m_mutex.try_lock()) return;
 
-		for (u32 i = 0; i < m_queue.list.GetCount(); i++)
+		for (u32 i = 0; i < m_queue.list.size(); i++)
 		{
 			if (u32 owner = m_queue.list[i]) ConLog.Write("Mutex(%d) was waited by thread %d", id, owner);
 		}
 
 		m_queue.m_mutex.unlock();
 	}
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Rwlock.cpp b/rpcs3/Emu/SysCalls/lv2/SC_Rwlock.cpp
index 2ca6ac53d3..d69d224b85 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_Rwlock.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/SC_Rwlock.cpp
@@ -42,7 +42,7 @@ int sys_rwlock_destroy(u32 rw_lock_id)
 
 	std::lock_guard<std::mutex> lock(rw->m_lock);
 
-	if (rw->wlock_queue.GetCount() || rw->rlock_list.GetCount() || rw->wlock_thread) return CELL_EBUSY;
+	if (rw->wlock_queue.size() || rw->rlock_list.size() || rw->wlock_thread) return CELL_EBUSY;
 
 	Emu.GetIdManager().RemoveID(rw_lock_id);
 
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Rwlock.h b/rpcs3/Emu/SysCalls/lv2/SC_Rwlock.h
index dc9c563b6d..c80baa9606 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_Rwlock.h
+++ b/rpcs3/Emu/SysCalls/lv2/SC_Rwlock.h
@@ -20,8 +20,8 @@ struct RWLock
 {
 	std::mutex m_lock; // internal lock
 	u32 wlock_thread; // write lock owner
-	Array<u32> wlock_queue; // write lock queue
-	Array<u32> rlock_list; // read lock list
+	std::vector<u32> wlock_queue; // write lock queue
+	std::vector<u32> rlock_list; // read lock list
 	u32 m_protocol; // TODO
 
 	union
@@ -41,9 +41,9 @@ struct RWLock
 	{
 		std::lock_guard<std::mutex> lock(m_lock);
 
-		if (!wlock_thread && !wlock_queue.GetCount())
+		if (!wlock_thread && !wlock_queue.size())
 		{
-			rlock_list.AddCpy(tid);
+			rlock_list.push_back(tid);
 			return true;
 		}
 		return false;
@@ -53,11 +53,11 @@ struct RWLock
 	{
 		std::lock_guard<std::mutex> lock(m_lock);
 
-		for (u32 i = rlock_list.GetCount() - 1; ~i; i--)
+		for (u32 i = rlock_list.size() - 1; ~i; i--)
 		{
 			if (rlock_list[i] == tid)
 			{
-				rlock_list.RemoveAt(i);
+				rlock_list.erase(rlock_list.begin() + i);
 				return true;
 			}
 		}
@@ -72,7 +72,7 @@ struct RWLock
 		{
 			return false; // deadlock
 		}
-		for (u32 i = rlock_list.GetCount() - 1; ~i; i--)
+		for (u32 i = rlock_list.size() - 1; ~i; i--)
 		{
 			if (rlock_list[i] == tid)
 			{
@@ -86,31 +86,31 @@ struct RWLock
 	{
 		std::lock_guard<std::mutex> lock(m_lock);
 
-		if (wlock_thread || rlock_list.GetCount()) // already locked
+		if (wlock_thread || rlock_list.size()) // already locked
 		{
 			if (!enqueue)
 			{
 				return false; // do not enqueue
 			}
-			for (u32 i = wlock_queue.GetCount() - 1; ~i; i--)
+			for (u32 i = wlock_queue.size() - 1; ~i; i--)
 			{
 				if (wlock_queue[i] == tid)
 				{
 					return false; // already enqueued
 				}
 			}
-			wlock_queue.AddCpy(tid); // enqueue new thread
+			wlock_queue.push_back(tid); // enqueue new thread
 			return false;
 		}
 		else
 		{
-			if (wlock_queue.GetCount())
+			if (wlock_queue.size())
 			{
 				// SYNC_FIFO only yet
 				if (wlock_queue[0] == tid)
 				{
 					wlock_thread = tid;
-					wlock_queue.RemoveAt(0);
+					wlock_queue.erase(wlock_queue.begin());
 					return true;
 				}
 				else
@@ -119,14 +119,14 @@ struct RWLock
 					{
 						return false; // do not enqueue
 					}
-					for (u32 i = wlock_queue.GetCount() - 1; ~i; i--)
+					for (u32 i = wlock_queue.size() - 1; ~i; i--)
 					{
 						if (wlock_queue[i] == tid)
 						{
 							return false; // already enqueued
 						}
 					}
-					wlock_queue.AddCpy(tid); // enqueue new thread
+					wlock_queue.push_back(tid); // enqueue new thread
 					return false;
 				}
 			}
@@ -149,4 +149,4 @@ struct RWLock
 		}
 		return false;
 	}
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.cpp b/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.cpp
index 4966e53781..92f2f174d9 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.cpp
@@ -91,7 +91,7 @@ int sys_spu_thread_initialize(mem32_t thread, u32 group, u32 spu_num, mem_ptr_t<
 		}
 	}
 
-	if(spu_num >= group_info->list.GetCount())
+	if(spu_num >= group_info->list.size())
 	{
 		return CELL_EINVAL;
 	}
@@ -204,7 +204,7 @@ int sys_spu_thread_group_destroy(u32 id)
 		return CELL_EBUSY;
 	}
 
-	for (u32 i = 0; i < group_info->list.GetCount(); i++)
+	for (u32 i = 0; i < group_info->list.size(); i++)
 	{
 		// TODO: disconnect all event ports
 
@@ -228,7 +228,7 @@ int sys_spu_thread_group_start(u32 id)
 
 	// TODO: check group state
 
-	for (u32 i = 0; i < group_info->list.GetCount(); i++)
+	for (u32 i = 0; i < group_info->list.size(); i++)
 	{
 		CPUThread* t;
 		if (t = Emu.GetCPU().GetThread(group_info->list[i]))
@@ -253,7 +253,7 @@ int sys_spu_thread_group_suspend(u32 id)
 
 	// TODO: check group state
 
-	for (u32 i = 0; i < group_info->list.GetCount(); i++)
+	for (u32 i = 0; i < group_info->list.size(); i++)
 	{
 		if (CPUThread* t = Emu.GetCPU().GetThread(group_info->list[i]))
 		{
@@ -277,7 +277,7 @@ int sys_spu_thread_group_resume(u32 id)
 
 	// TODO: check group state
 
-	for (u32 i = 0; i < group_info->list.GetCount(); i++)
+	for (u32 i = 0; i < group_info->list.size(); i++)
 	{
 		if (CPUThread* t = Emu.GetCPU().GetThread(group_info->list[i]))
 		{
@@ -331,7 +331,7 @@ int sys_spu_thread_group_join(u32 id, mem32_t cause, mem32_t status)
 	cause = SYS_SPU_THREAD_GROUP_JOIN_ALL_THREADS_EXIT;
 	status = 0; //unspecified because of ALL_THREADS_EXIT
 
-	for (u32 i = 0; i < group_info->list.GetCount(); i++)
+	for (u32 i = 0; i < group_info->list.size(); i++)
 	{
 		while (CPUThread* t = Emu.GetCPU().GetThread(group_info->list[i]))
 		{
@@ -725,7 +725,7 @@ int sys_spu_thread_group_connect_event_all_threads(u32 id, u32 eq, u64 req, u32
 	}
 	
 	/*
-	for(u32 i=0; i<group->list.GetCount(); ++i)
+	for(u32 i=0; i<group->list.size(); ++i)
 	{
 		CPUThread* t;
 		if(t = Emu.GetCPU().GetThread(group->list[i]))
@@ -754,4 +754,4 @@ int sys_spu_thread_group_disconnect_event_all_threads(u32 id, u8 spup)
 	sc_spu.Error("sys_spu_thread_group_disconnect_event_all_threads(id=%d, spup=%d)", id, spup);
 
 	return CELL_OK;
-}
\ No newline at end of file
+}
diff --git a/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.h b/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.h
index 3c7d320ed7..12f07ef1d7 100644
--- a/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.h
+++ b/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.h
@@ -58,7 +58,7 @@ struct sys_spu_segment
 
 struct SpuGroupInfo
 {
-	Array<u32> list;
+	std::vector<u32> list;
 	std::atomic<u32> lock;
 	std::string m_name;
 	int m_prio;
@@ -73,10 +73,10 @@ struct SpuGroupInfo
 		, lock(0)
 	{
 		num = 256;
-		list.SetCount(num);
+		list.resize(num);
 		for (u32 i = 0; i < num; i++)
 		{
 			list[i] = 0;
 		}
 	}
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp
index afe861905f..1ed7dc1148 100644
--- a/rpcs3/Emu/System.cpp
+++ b/rpcs3/Emu/System.cpp
@@ -17,7 +17,7 @@ static const u16 bpdb_version = 0x1000;
 
 ModuleInitializer::ModuleInitializer()
 {
-	Emu.AddModuleInit(this);
+	Emu.AddModuleInit(std::move(std::unique_ptr<ModuleInitializer>(this)));
 }
 
 Emulator::Emulator()
@@ -32,10 +32,10 @@ Emulator::Emulator()
 
 void Emulator::Init()
 {
-	while(m_modules_init.GetCount())
+	while(m_modules_init.size())
 	{
-		m_modules_init[0].Init();
-		m_modules_init.RemoveAt(0);
+		m_modules_init[0]->Init();
+		m_modules_init.erase(m_modules_init.begin());
 	}
 	//if(m_memory_viewer) m_memory_viewer->Close();
 	//m_memory_viewer = new MemoryViewerPanel(wxGetApp().m_MainFrame);
@@ -54,17 +54,17 @@ void Emulator::SetTitleID(const std::string& id)
 
 void Emulator::CheckStatus()
 {
-	ArrayF<CPUThread>& threads = GetCPU().GetThreads();
-	if(!threads.GetCount())
+	std::vector<CPUThread *>& threads = GetCPU().GetThreads();
+	if(!threads.size())
 	{
 		Stop();
 		return;	
 	}
 
 	bool IsAllPaused = true;
-	for(u32 i=0; i<threads.GetCount(); ++i)
+	for(u32 i=0; i<threads.size(); ++i)
 	{
-		if(threads[i].IsPaused()) continue;
+		if(threads[i]->IsPaused()) continue;
 		IsAllPaused = false;
 		break;
 	}
@@ -76,9 +76,9 @@ void Emulator::CheckStatus()
 	}
 
 	bool IsAllStoped = true;
-	for(u32 i=0; i<threads.GetCount(); ++i)
+	for(u32 i=0; i<threads.size(); ++i)
 	{
-		if(threads[i].IsStopped()) continue;
+		if(threads[i]->IsStopped()) continue;
 		IsAllStoped = false;
 		break;
 	}
@@ -147,9 +147,9 @@ void Emulator::Load()
 
 	ConLog.SkipLn();
 	ConLog.Write("Mount info:");
-	for(uint i=0; i<m_vfs.m_devices.GetCount(); ++i)
+	for(uint i=0; i<m_vfs.m_devices.size(); ++i)
 	{
-		ConLog.Write("%s -> %s", m_vfs.m_devices[i].GetPs3Path().c_str(), m_vfs.m_devices[i].GetLocalPath().c_str());
+		ConLog.Write("%s -> %s", m_vfs.m_devices[i]->GetPs3Path().c_str(), m_vfs.m_devices[i]->GetLocalPath().c_str());
 	}
 	ConLog.SkipLn();
 
@@ -377,8 +377,8 @@ void Emulator::Stop()
 	m_rsx_callback = 0;
 
 	SavePoints(BreakPointsDBName);
-	m_break_points.Clear();
-	m_marked_points.Clear();
+	m_break_points.clear();
+	m_marked_points.clear();
 
 	m_vfs.UnMountAll();
 
@@ -407,8 +407,8 @@ void Emulator::SavePoints(const std::string& path)
 {
 	std::ofstream f(path, std::ios::binary | std::ios::trunc);
 
-	u32 break_count = m_break_points.GetCount();
-	u32 marked_count = m_marked_points.GetCount();
+	u32 break_count = m_break_points.size();
+	u32 marked_count = m_marked_points.size();
 
 	f << bpdb_version << break_count << marked_count;
 	
@@ -447,13 +447,13 @@ void Emulator::LoadPoints(const std::string& path)
 
 	if(break_count > 0)
 	{
-		m_break_points.SetCount(break_count);
+		m_break_points.resize(break_count);
 		f.read(reinterpret_cast<char*>(&m_break_points[0]), sizeof(u64) * break_count);
 	}
 
 	if(marked_count > 0)
 	{
-		m_marked_points.SetCount(marked_count);
+		m_marked_points.resize(marked_count);
 		f.read(reinterpret_cast<char*>(&m_marked_points[0]), sizeof(u64) * marked_count);
 	}
 }
diff --git a/rpcs3/Emu/System.h b/rpcs3/Emu/System.h
index d963e6d0e5..63755b65f3 100644
--- a/rpcs3/Emu/System.h
+++ b/rpcs3/Emu/System.h
@@ -76,10 +76,10 @@ class Emulator
 	u32 m_ppu_thr_exit;
 	MemoryViewerPanel* m_memory_viewer;
 	//ArrayF<CPUThread> m_cpu_threads;
-	ArrayF<ModuleInitializer> m_modules_init;
+	std::vector<std::unique_ptr<ModuleInitializer>> m_modules_init;
 
-	Array<u64> m_break_points;
-	Array<u64> m_marked_points;
+	std::vector<u64> m_break_points;
+	std::vector<u64> m_marked_points;
 
 	CPUThreadManager m_thread_manager;
 	PadManager m_pad_manager;
@@ -118,14 +118,14 @@ public:
 	AudioManager&     GetAudioManager()    { return m_audio_manager; }
 	CallbackManager&  GetCallbackManager() { return m_callback_manager; }
 	VFS&              GetVFS()             { return m_vfs; }
-	Array<u64>&       GetBreakPoints()     { return m_break_points; }
-	Array<u64>&       GetMarkedPoints()    { return m_marked_points; }
+	std::vector<u64>& GetBreakPoints()     { return m_break_points; }
+	std::vector<u64>& GetMarkedPoints()    { return m_marked_points; }
 	CPUThread&        GetCallbackThread()  { return *m_ppu_callback_thr; }
 	EventManager&     GetEventManager()    { return *m_event_manager; }
 	
-	void AddModuleInit(ModuleInitializer* m)
+	void AddModuleInit(std::unique_ptr<ModuleInitializer> m)
 	{
-		m_modules_init.Add(m);
+		m_modules_init.push_back(std::move(m));
 	}
 
 	void SetTLSData(const u64 addr, const u64 filesz, const u64 memsz)
@@ -162,4 +162,4 @@ public:
 	__forceinline bool IsReady()   const { return m_status == Ready; }
 };
 
-extern Emulator Emu;
\ No newline at end of file
+extern Emulator Emu;
diff --git a/rpcs3/Emu/event.h b/rpcs3/Emu/event.h
index 6d1df5cf0f..a9a3630c45 100644
--- a/rpcs3/Emu/event.h
+++ b/rpcs3/Emu/event.h
@@ -69,7 +69,7 @@ struct EventPort
 
 class EventRingBuffer
 {
-	Array<sys_event_data> data;
+	std::vector<sys_event_data> data;
 	SMutex m_lock;
 	u32 buf_pos;
 	u32 buf_count;
@@ -82,7 +82,7 @@ public:
 		, buf_pos(0)
 		, buf_count(0)
 	{
-		data.SetCount(size);
+		data.resize(size);
 	}
 
 	void clear()
@@ -151,7 +151,7 @@ public:
 
 class EventPortList
 {
-	Array<EventPort*> data;
+	std::vector<EventPort*> data;
 	SMutex m_lock;
 
 public:
@@ -159,28 +159,28 @@ public:
 	void clear()
 	{
 		SMutexLocker lock(m_lock);
-		for (u32 i = 0; i < data.GetCount(); i++)
+		for (u32 i = 0; i < data.size(); i++)
 		{
 			SMutexLocker lock2(data[i]->mutex);
 			data[i]->eq = nullptr; // force all ports to disconnect
 		}
-		data.Clear();
+		data.clear();
 	}
 
 	void add(EventPort* port)
 	{
 		SMutexLocker lock(m_lock);
-		data.AddCpy(port);
+		data.push_back(port);
 	}
 
 	void remove(EventPort* port)
 	{
 		SMutexLocker lock(m_lock);
-		for (u32 i = 0; i < data.GetCount(); i++)
+		for (u32 i = 0; i < data.size(); i++)
 		{
 			if (data[i] == port)
 			{
-				data.RemoveAt(i);
+				data.erase(data.begin() + i);
 				return;
 			}
 		}
@@ -226,4 +226,4 @@ public:
 	bool GetEventQueue(u64 key, EventQueue*& data);
 	bool UnregisterKey(u64 key);
 	bool SendEvent(u64 key, u64 source, u64 d1, u64 d2, u64 d3);
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Gui/ConLog.cpp b/rpcs3/Gui/ConLog.cpp
index ef68f84a9f..9632e02256 100644
--- a/rpcs3/Gui/ConLog.cpp
+++ b/rpcs3/Gui/ConLog.cpp
@@ -46,7 +46,7 @@ struct _LogBuffer : public MTPacketBuffer<LogPacket>
 		const u32 stext   = data.m_text.length();
 		const u32 scolour = data.m_colour.length();
 
-		m_buffer.Reserve(
+		m_buffer.resize( m_buffer.size() +
 			sizeof(u32) + sprefix +
 			sizeof(u32) + stext +
 			sizeof(u32) + scolour);
diff --git a/rpcs3/Gui/DisAsmFrame.cpp b/rpcs3/Gui/DisAsmFrame.cpp
index aa365cbb8f..8bcb5b36f2 100644
--- a/rpcs3/Gui/DisAsmFrame.cpp
+++ b/rpcs3/Gui/DisAsmFrame.cpp
@@ -104,8 +104,8 @@ void DisAsmFrame::Resume()
 
 #include <Utilities/MTProgressDialog.h>
 #include "Loader/ELF.h"
-Array<Elf64_Shdr>* shdr_arr_64 = NULL;
-Array<Elf32_Shdr>* shdr_arr_32 = NULL;
+std::vector<Elf64_Shdr>* shdr_arr_64 = NULL;
+std::vector<Elf32_Shdr>* shdr_arr_32 = NULL;
 ELF64Loader* l_elf64 = NULL;
 ELF32Loader* l_elf32 = NULL;
 bool ElfType64 = false;
@@ -135,7 +135,7 @@ public:
 
 		*done = false;
 
-		if(Emu.GetCPU().GetThreads()[0].GetType() != CPU_THREAD_PPU)
+		if(Emu.GetCPU().GetThreads()[0]->GetType() != CPU_THREAD_PPU)
 		{
 			SPUDisAsm& dis_asm = *new SPUDisAsm(CPUDisAsm_DumpMode);
 			decoder = new SPUDecoder(dis_asm);
@@ -143,9 +143,9 @@ public:
 		}
 		else
 		{
-			PPUDisAsm& dis_asm = *new PPUDisAsm(CPUDisAsm_DumpMode);
+			PPUDisAsm* dis_asm = new PPUDisAsm(CPUDisAsm_DumpMode);
 			decoder = new PPUDecoder(dis_asm);
-			disasm = &dis_asm;
+			disasm = dis_asm;
 		}
 	}
 
@@ -153,7 +153,7 @@ public:
 	{
 		ConLog.Write("Start dump in thread %d!", (int)id);
 		const u32 max_value = prog_dial->GetMaxValue(id);
-		const u32 shdr_count = ElfType64 ? shdr_arr_64->GetCount() : shdr_arr_32->GetCount();
+		const u32 shdr_count = ElfType64 ? shdr_arr_64->size() : shdr_arr_32->size();
 
 		for(u32 sh=0, vsize=0; sh<shdr_count; ++sh)
 		{
@@ -235,7 +235,7 @@ struct WaitDumperThread : public ThreadBase
 		wxFile fd;
 		fd.Open(patch, wxFile::write);
 
-		const u32 shdr_count = ElfType64 ? shdr_arr_64->GetCount() : shdr_arr_32->GetCount();
+		const u32 shdr_count = ElfType64 ? shdr_arr_64->size() : shdr_arr_32->size();
 
 		for(uint sh=0, counter=0; sh<shdr_count; ++sh)
 		{
@@ -320,7 +320,7 @@ void DisAsmFrame::Dump(wxCommandEvent& WXUNUSED(event))
 		}
 		name_arr = l_elf64->shdr_name_arr;
 		shdr_arr_64 = &l_elf64->shdr_arr;
-		if(l_elf64->shdr_arr.GetCount() <= 0) return;
+		if(l_elf64->shdr_arr.size() <= 0) return;
 	break;
 
 	case CLASS_ELF32:
@@ -334,7 +334,7 @@ void DisAsmFrame::Dump(wxCommandEvent& WXUNUSED(event))
 
 		name_arr = l_elf32->shdr_name_arr;
 		shdr_arr_32 = &l_elf32->shdr_arr;
-		if(l_elf32->shdr_arr.GetCount() <= 0) return;
+		if(l_elf32->shdr_arr.size() <= 0) return;
 	break;
 
 	default: ConLog.Error("Corrupted ELF!"); return;
@@ -343,13 +343,13 @@ void DisAsmFrame::Dump(wxCommandEvent& WXUNUSED(event))
 	PPCDisAsm* disasm;
 	PPCDecoder* decoder;
 
-	switch(Emu.GetCPU().GetThreads()[0].GetType())
+	switch(Emu.GetCPU().GetThreads()[0]->GetType())
 	{
 	case CPU_THREAD_PPU:
 	{
-		PPUDisAsm& dis_asm = *new PPUDisAsm(CPUDisAsm_DumpMode);
+		PPUDisAsm* dis_asm = new PPUDisAsm(CPUDisAsm_DumpMode);
 		decoder = new PPUDecoder(dis_asm);
-		disasm = &dis_asm;
+		disasm = dis_asm;
 	}
 	break;
 
@@ -363,7 +363,7 @@ void DisAsmFrame::Dump(wxCommandEvent& WXUNUSED(event))
 	break;
 	}
 
-	const u32 shdr_count = ElfType64 ? shdr_arr_64->GetCount() : shdr_arr_32->GetCount();
+	const u32 shdr_count = ElfType64 ? shdr_arr_64->size() : shdr_arr_32->size();
 
 	u64 max_count = 0;
 	for(u32 sh=0; sh<shdr_count; ++sh)
diff --git a/rpcs3/Gui/FnIdGenerator.cpp b/rpcs3/Gui/FnIdGenerator.cpp
index aabfe9766c..19a11dd095 100644
--- a/rpcs3/Gui/FnIdGenerator.cpp
+++ b/rpcs3/Gui/FnIdGenerator.cpp
@@ -37,9 +37,8 @@ FnIdGenerator::FnIdGenerator(wxWindow* parent)
 
 FnIdGenerator::~FnIdGenerator()
 {
-	m_func_name.Clear();
-	m_func_id.Clear();
 	delete m_list;
+	m_list = nullptr;
 }
 
 void FnIdGenerator::OnInput(wxCommandEvent &event)
@@ -51,8 +50,8 @@ void FnIdGenerator::OnInput(wxCommandEvent &event)
 void FnIdGenerator::OnClear(wxCommandEvent &event)
 {
 	m_list->DeleteAllItems();
-	m_func_name.Clear();
-	m_func_id.Clear();
+	m_func_name.clear();
+	m_func_id.clear();
 	event.Skip();
 }
 
@@ -82,8 +81,8 @@ void FnIdGenerator::PrintId()
 		return;
 
 	const be_t<u32> result = GenerateFnId(func_name);
-	m_func_name.AddCpy(func_name);
-	m_func_id.AddCpy(result);
+	m_func_name.push_back(func_name);
+	m_func_id.push_back(result);
 
 	ConLog.Write("Function: %s, Id: 0x%08x ", func_name.c_str(), result);
 	UpdateInformation();
@@ -93,9 +92,9 @@ void FnIdGenerator::UpdateInformation()
 {
 	m_list->DeleteAllItems();
 
-	for(u32 i = 0; i < m_func_name.GetCount(); i++)
+	for(u32 i = 0; i < m_func_name.size(); i++)
 	{
-		m_list->InsertItem(m_func_name.GetCount(), wxEmptyString);
+		m_list->InsertItem(m_func_name.size(), wxEmptyString);
 		m_list->SetItem(i, 0, m_func_name[i]);
 		m_list->SetItem(i, 1, wxString::Format("0x%08x", re(m_func_id[i])));
 	}
diff --git a/rpcs3/Gui/FnIdGenerator.h b/rpcs3/Gui/FnIdGenerator.h
index 4f9eebcf9f..e745e9ddd0 100644
--- a/rpcs3/Gui/FnIdGenerator.h
+++ b/rpcs3/Gui/FnIdGenerator.h
@@ -5,8 +5,8 @@
 class FnIdGenerator : public wxDialog
 {
 private:
-	Array<std::string> m_func_name;
-	Array<u32> m_func_id;
+	std::vector<std::string> m_func_name;
+	std::vector<u32> m_func_id;
 	wxListView* m_list;
 
 public:
diff --git a/rpcs3/Gui/GameViewer.h b/rpcs3/Gui/GameViewer.h
index 3a8bd61c68..d31fc241fc 100644
--- a/rpcs3/Gui/GameViewer.h
+++ b/rpcs3/Gui/GameViewer.h
@@ -28,40 +28,40 @@ struct Column
 
 struct ColumnsArr
 {
-	ArrayF<Column> m_columns;
+	std::vector<Column> m_columns;
 
 	ColumnsArr()
 	{
 		Init();
 	}
 
-	ArrayF<Column>* GetSortedColumnsByPos()
+	std::vector<Column*> GetSortedColumnsByPos()
 	{
-		static ArrayF<Column>& arr = *new ArrayF<Column>(); arr.ClearF();
-		for(u32 pos=0; pos<m_columns.GetCount(); pos++)
+		std::vector<Column*> arr;
+		for(u32 pos=0; pos<m_columns.size(); pos++)
 		{
-			for(u32 c=0; c<m_columns.GetCount(); ++c)
+			for(u32 c=0; c<m_columns.size(); ++c)
 			{
 				if(m_columns[c].pos != pos) continue;
-				arr.Add(m_columns[c]);
+				arr.push_back(&m_columns[c]);
 			}
 		}
 
-		return &arr;
+		return arr;
 	}
 
 	Column* GetColumnByPos(u32 pos)
 	{
-		ArrayF<Column>& columns = *GetSortedColumnsByPos();
-		for(u32 c=0; c<columns.GetCount(); ++c)
+		std::vector<Column *> columns = GetSortedColumnsByPos();
+		for(u32 c=0; c<columns.size(); ++c)
 		{
-			if(!columns[c].shown)
+			if(!columns[c]->shown)
 			{
 				pos++;
 				continue;
 			}
-			if(columns[c].pos != pos) continue;
-			return &columns[c];
+			if(columns[c]->pos != pos) continue;
+			return columns[c];
 		}
 
 		return NULL;
@@ -77,16 +77,19 @@ public:
 
 	void Init()
 	{
-		m_columns.Clear();
-
-		#define ADD_COLUMN(x, w, n) x = new Column(m_columns.GetCount(), w, n);	m_columns.Add(x);
-			ADD_COLUMN(m_col_name, 160, "Name");
-			ADD_COLUMN(m_col_serial, 85, "Serial");
-			ADD_COLUMN(m_col_fw, 55, "FW");
-			ADD_COLUMN(m_col_app_ver, 55, "App version");
-			ADD_COLUMN(m_col_category, 55, "Category");
-			ADD_COLUMN(m_col_path, 160, "Path");
-		#undef ADD_COLUMN
+		m_columns.clear();
+		m_columns.emplace_back(m_columns.size(), 160, "Name");
+		m_columns.emplace_back(m_columns.size(),  85, "Serial");
+		m_columns.emplace_back(m_columns.size(),  55, "FW");
+		m_columns.emplace_back(m_columns.size(),  55, "App version");
+		m_columns.emplace_back(m_columns.size(),  55, "Category");
+		m_columns.emplace_back(m_columns.size(), 160, "Path");
+		m_col_name     = &m_columns[0];
+		m_col_serial   = &m_columns[1];
+		m_col_fw       = &m_columns[2];
+		m_col_app_ver  = &m_columns[3];
+		m_col_category = &m_columns[4];
+		m_col_path     = &m_columns[5];
 	}
 
 	void Update(std::vector<GameInfo>& game_data)
@@ -98,7 +101,7 @@ public:
 		m_col_category->data.clear();
 		m_col_path->data.clear();
 
-		if(m_columns.GetCount() == 0) return;
+		if(m_columns.size() == 0) return;
 
 		for(const auto& game : game_data)
 		{
@@ -114,11 +117,11 @@ public:
 	void Show(wxListView* list)
 	{
 		list->DeleteAllColumns();
-		ArrayF<Column>& c_col = *GetSortedColumnsByPos();
-		for(u32 i=0, c=0; i<c_col.GetCount(); ++i)
+		std::vector<Column *> c_col = GetSortedColumnsByPos();
+		for(u32 i=0, c=0; i<c_col.size(); ++i)
 		{
-			if(!c_col[i].shown) continue;
-			list->InsertColumn(c++, fmt::FromUTF8(c_col[i].name), 0, c_col[i].width);
+			if(!c_col[i]->shown) continue;
+			list->InsertColumn(c++, fmt::FromUTF8(c_col[i]->name), 0, c_col[i]->width);
 		}
 	}
 
@@ -167,7 +170,7 @@ public:
 			} \
 		}
 
-		for(u32 i=0; i<m_columns.GetCount(); ++i)
+		for(u32 i=0; i<m_columns.size(); ++i)
 		{
 			ADD_COLUMN(pos, m_columns[i].def_pos, int, "position", 1);
 			ADD_COLUMN(width, m_columns[i].def_width, int, "width", 1);
@@ -177,9 +180,9 @@ public:
 		if(isLoad)
 		{
 			//check for errors
-			for(u32 c1=0; c1<m_columns.GetCount(); ++c1)
+			for(u32 c1=0; c1<m_columns.size(); ++c1)
 			{
-				for(u32 c2=c1+1; c2<m_columns.GetCount(); ++c2)
+				for(u32 c2=c1+1; c2<m_columns.size(); ++c2)
 				{
 					if(m_columns[c1].pos == m_columns[c2].pos)
 					{
@@ -190,10 +193,10 @@ public:
 				}
 			}
 
-			for(u32 p=0; p<m_columns.GetCount(); ++p)
+			for(u32 p=0; p<m_columns.size(); ++p)
 			{
 				bool ishas = false;
-				for(u32 c=0; c<m_columns.GetCount(); ++c)
+				for(u32 c=0; c<m_columns.size(); ++c)
 				{
 					if(m_columns[c].pos != p) continue;
 					ishas = true;
@@ -237,4 +240,4 @@ public:
 
 private:
 	virtual void DClick(wxListEvent& event);
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Gui/InterpreterDisAsm.cpp b/rpcs3/Gui/InterpreterDisAsm.cpp
index f240878ab7..596516b9bc 100644
--- a/rpcs3/Gui/InterpreterDisAsm.cpp
+++ b/rpcs3/Gui/InterpreterDisAsm.cpp
@@ -104,9 +104,9 @@ void InterpreterDisAsmFrame::UpdateUnitList()
 	m_choice_units->Clear();
 	auto& thrs = Emu.GetCPU().GetThreads();
 
-	for(uint i=0; i<thrs.GetCount(); ++i)
+	for(uint i=0; i<thrs.size(); ++i)
 	{
-		m_choice_units->Append(thrs[i].GetFName(), &thrs[i]);
+		m_choice_units->Append(thrs[i]->GetFName(), thrs[i]);
 	}
 
 	m_choice_units->Thaw();
@@ -127,9 +127,9 @@ void InterpreterDisAsmFrame::OnSelectUnit(wxCommandEvent& event)
 		{
 		case CPU_THREAD_PPU:
 		{
-			PPUDisAsm& dis_asm = *new PPUDisAsm(CPUDisAsm_InterpreterMode);
+			PPUDisAsm* dis_asm = new PPUDisAsm(CPUDisAsm_InterpreterMode);
 			decoder = new PPUDecoder(dis_asm);
-			disasm = &dis_asm;
+			disasm = dis_asm;
 		}
 		break;
 
@@ -274,7 +274,7 @@ void InterpreterDisAsmFrame::ShowAddr(const u64 addr)
 			{
 				colour = wxColour("White");
 
-				for(u32 i=0; i<Emu.GetMarkedPoints().GetCount(); ++i)
+				for(u32 i=0; i<Emu.GetMarkedPoints().size(); ++i)
 				{
 					if(Emu.GetMarkedPoints()[i] == PC)
 					{
@@ -288,22 +288,22 @@ void InterpreterDisAsmFrame::ShowAddr(const u64 addr)
 		}
 	}
 
-	while(remove_markedPC.GetCount())
+	while(remove_markedPC.size())
 	{
 		u32 mpc = remove_markedPC[0];
 
-		for(u32 i=0; i<remove_markedPC.GetCount(); ++i)
+		for(u32 i=0; i<remove_markedPC.size(); ++i)
 		{
 			if(remove_markedPC[i] == mpc)
 			{
-				remove_markedPC.RemoveAt(i--);
+				remove_markedPC.erase( remove_markedPC.begin() + i--);
 				continue;
 			}
 
 			if(remove_markedPC[i] > mpc) remove_markedPC[i]--;
 		}
 
-		Emu.GetMarkedPoints().RemoveAt(mpc);
+		Emu.GetMarkedPoints().erase(Emu.GetMarkedPoints().begin() + mpc);
 	}
 
 	m_list->SetColumnWidth(0, -1);
@@ -456,7 +456,8 @@ void InterpreterDisAsmFrame::Show_Val(wxCommandEvent& WXUNUSED(event))
 	{
 		u64 pc = CPU ? CPU->PC : 0x0;
 		sscanf(p_pc->GetValue(), "%llx", &pc);
-		remove_markedPC.AddCpy(Emu.GetMarkedPoints().AddCpy(pc));
+		Emu.GetMarkedPoints().push_back(pc);
+		remove_markedPC.push_back(Emu.GetMarkedPoints().size()-1);
 		ShowAddr(CentrePc(pc));
 	}
 }
@@ -551,7 +552,7 @@ void InterpreterDisAsmFrame::MouseWheel(wxMouseEvent& event)
 
 bool InterpreterDisAsmFrame::IsBreakPoint(u64 pc)
 {
-	for(u32 i=0; i<Emu.GetBreakPoints().GetCount(); ++i)
+	for(u32 i=0; i<Emu.GetBreakPoints().size(); ++i)
 	{
 		if(Emu.GetBreakPoints()[i] == pc) return true;
 	}
@@ -561,20 +562,20 @@ bool InterpreterDisAsmFrame::IsBreakPoint(u64 pc)
 
 void InterpreterDisAsmFrame::AddBreakPoint(u64 pc)
 {
-	for(u32 i=0; i<Emu.GetBreakPoints().GetCount(); ++i)
+	for(u32 i=0; i<Emu.GetBreakPoints().size(); ++i)
 	{
 		if(Emu.GetBreakPoints()[i] == pc) return;
 	}
 
-	Emu.GetBreakPoints().AddCpy(pc);
+	Emu.GetBreakPoints().push_back(pc);
 }
 
 bool InterpreterDisAsmFrame::RemoveBreakPoint(u64 pc)
 {
-	for(u32 i=0; i<Emu.GetBreakPoints().GetCount(); ++i)
+	for(u32 i=0; i<Emu.GetBreakPoints().size(); ++i)
 	{
 		if(Emu.GetBreakPoints()[i] != pc) continue;
-		Emu.GetBreakPoints().RemoveAt(i);
+		Emu.GetBreakPoints().erase(Emu.GetBreakPoints().begin() + i);
 		return true;
 	}
 
diff --git a/rpcs3/Gui/InterpreterDisAsm.h b/rpcs3/Gui/InterpreterDisAsm.h
index 3069b5e730..217202f22d 100644
--- a/rpcs3/Gui/InterpreterDisAsm.h
+++ b/rpcs3/Gui/InterpreterDisAsm.h
@@ -9,7 +9,7 @@ class InterpreterDisAsmFrame : public wxPanel
 	CPUDisAsm* disasm;
 	CPUDecoder* decoder;
 	u64 PC;
-	Array<u32> remove_markedPC;
+	std::vector<u32> remove_markedPC;
 	wxTextCtrl* m_regs;
 	wxTextCtrl* m_calls;
 	wxButton* m_btn_step;
@@ -51,4 +51,4 @@ public:
 	bool IsBreakPoint(u64 pc);
 	void AddBreakPoint(u64 pc);
 	bool RemoveBreakPoint(u64 pc);
-};
\ No newline at end of file
+};
diff --git a/rpcs3/Gui/MainFrame.cpp b/rpcs3/Gui/MainFrame.cpp
index 27617f42e4..c6e2338d30 100644
--- a/rpcs3/Gui/MainFrame.cpp
+++ b/rpcs3/Gui/MainFrame.cpp
@@ -669,7 +669,7 @@ void MainFrame::UpdateUI(wxCommandEvent& event)
 	pause.Enable(!is_stopped);
 	stop.Enable(!is_stopped);
 	//send_exit.Enable(false);
-	bool enable_commands = !is_stopped && Emu.GetCallbackManager().m_exit_callback.m_callbacks.GetCount();
+	bool enable_commands = !is_stopped && Emu.GetCallbackManager().m_exit_callback.m_callbacks.size();
 
 	send_open_menu.SetItemLabel(wxString::Format("Send %s system menu cmd", (m_sys_menu_opened ? "close" : "open")));
 	send_open_menu.Enable(enable_commands);
diff --git a/rpcs3/Gui/Plugins.h b/rpcs3/Gui/Plugins.h
index 0cffa91ad2..b527a5c139 100644
--- a/rpcs3/Gui/Plugins.h
+++ b/rpcs3/Gui/Plugins.h
@@ -299,14 +299,14 @@ struct PluginsManager
 		u32 type;
 	};
 
-	Array<PluginInfo> m_plugins;
-	ArrayF<PluginInfo> m_pad_plugins;
+	std::vector<PluginInfo> m_plugins;
+	std::vector<PluginInfo*> m_pad_plugins;
 
 	void Load(const wxString& path)
 	{
 		if(!wxDirExists(path)) return;
 
-		m_plugins.ClearD();
+		m_plugins.clear();
 		wxDir dir(path);
 
 		wxArrayString res;
@@ -318,11 +318,11 @@ struct PluginsManager
 			Ps3EmuPlugin l(res[i]);
 			if(!l.Test()) continue;
 
-			PluginInfo& info = *new PluginInfo();
+			m_plugins.emplace_back();
+			PluginInfo& info = m_plugins.back();
 			info.path = res[i];
 			info.name.Printf("%s v%s", l.Ps3EmuLibGetFullName(), l.FormatVersion());
 			info.type = l.Ps3EmuLibGetType();
-			m_plugins.Add(info);
 		}
 	}
 
@@ -345,11 +345,11 @@ struct PluginsManager
 		wxComboBox* cbox_pad_plugins;
 		s_panel.Add(GetNewComboBox(&dial, "Pad", cbox_pad_plugins), wxSizerFlags().Border(wxALL, 5).Expand());
 
-		for(u32 i=0; i<m_plugins.GetCount(); ++i)
+		for(u32 i=0; i<m_plugins.size(); ++i)
 		{
 			if(m_plugins[i].type & Ps3EmuPlugin::LIB_PAD)
 			{
-				m_pad_plugins.Add(m_plugins[i]);
+				m_pad_plugins.push_back(&m_plugins[i]);
 				cbox_pad_plugins->Append(m_plugins[i].name + " (" + wxFileName(m_plugins[i].path).GetName() + ")");
 			}
 		}
diff --git a/rpcs3/Ini.cpp b/rpcs3/Ini.cpp
index 28b8375084..42f94a3e62 100644
--- a/rpcs3/Ini.cpp
+++ b/rpcs3/Ini.cpp
@@ -159,6 +159,11 @@ Ini::Ini()
 #endif
 }
 
+Ini::~Ini()
+{
+	safe_delete(m_Config);
+}
+
 void Ini::Save(const wxString& key, int value)
 {
 	m_Config->Write(key, value);
diff --git a/rpcs3/Ini.h b/rpcs3/Ini.h
index a2a0da1d7c..a83c26f7bd 100644
--- a/rpcs3/Ini.h
+++ b/rpcs3/Ini.h
@@ -21,10 +21,14 @@ struct WindowInfo
 
 class Ini
 {
+public:
+	virtual ~Ini();
+
 protected:
 	wxConfigBase* m_Config;
 
 	Ini();
+
 	void Save(const wxString& key, int value);
 	void Save(const wxString& key, bool value);
 	void Save(const wxString& key, wxSize value);
diff --git a/rpcs3/Loader/ELF.h b/rpcs3/Loader/ELF.h
index 1c41cba251..cbb9d88473 100644
--- a/rpcs3/Loader/ELF.h
+++ b/rpcs3/Loader/ELF.h
@@ -48,7 +48,7 @@ public:
 	Elf_Ehdr ehdr;
 
 	ELFLoader(vfsStream& f);
-	~ELFLoader() {Close();}
+	virtual ~ELFLoader() {Close();}
 
 	virtual bool LoadInfo();
 	virtual bool LoadData(u64 offset = 0);
diff --git a/rpcs3/Loader/ELF32.cpp b/rpcs3/Loader/ELF32.cpp
index a68a0c2ce1..82d849a4ec 100644
--- a/rpcs3/Loader/ELF32.cpp
+++ b/rpcs3/Loader/ELF32.cpp
@@ -129,10 +129,11 @@ bool ELF32Loader::LoadPhdrInfo()
 	elf32_f.Seek(ehdr.e_phoff);
 	for(uint i=0; i<ehdr.e_phnum; ++i)
 	{
-		Elf32_Phdr* phdr = new Elf32_Phdr();
-		if(ehdr.IsLittleEndian()) phdr->LoadLE(elf32_f);
-		else phdr->Load(elf32_f);
-		phdr_arr.Move(phdr);
+		phdr_arr.emplace_back();
+		if(ehdr.IsLittleEndian())
+			phdr_arr.back().LoadLE(elf32_f);
+		else
+			phdr_arr.back().Load(elf32_f);
 	}
 
 	if(/*!Memory.IsGoodAddr(entry)*/ entry & 0x1)
@@ -141,7 +142,7 @@ bool ELF32Loader::LoadPhdrInfo()
 
 		entry &= ~0x1;
 
-		for(size_t i=0; i<phdr_arr.GetCount(); ++i)
+		for(size_t i=0; i<phdr_arr.size(); ++i)
 		{
 			if(phdr_arr[i].p_paddr >= entry && entry < phdr_arr[i].p_paddr + phdr_arr[i].p_memsz)
 			{
@@ -160,31 +161,32 @@ bool ELF32Loader::LoadShdrInfo()
 	elf32_f.Seek(ehdr.e_shoff);
 	for(u32 i=0; i<ehdr.e_shnum; ++i)
 	{
-		Elf32_Shdr* shdr = new Elf32_Shdr();
-		if(ehdr.IsLittleEndian()) shdr->LoadLE(elf32_f);
-		else shdr->Load(elf32_f);
-		shdr_arr.Move(shdr);
+		shdr_arr.emplace_back();
+		if(ehdr.IsLittleEndian())
+			shdr_arr.back().LoadLE(elf32_f);
+		else
+			shdr_arr.back().Load(elf32_f);
+
 	}
 
-	if(ehdr.e_shstrndx >= shdr_arr.GetCount())
+	if(ehdr.e_shstrndx >= shdr_arr.size())
 	{
 		ConLog.Warning("LoadShdr32 error: shstrndx too big!");
 		return true;
 	}
 
-	for(u32 i=0; i<shdr_arr.GetCount(); ++i)
+	for(u32 i=0; i<shdr_arr.size(); ++i)
 	{
 		elf32_f.Seek(shdr_arr[ehdr.e_shstrndx].sh_offset + shdr_arr[i].sh_name);
-		Array<char> name;
+		std::string name;
 		while(!elf32_f.Eof())
 		{
 			char c;
 			elf32_f.Read(&c, 1);
 			if(c == 0) break;
-			name.AddCpy(c);
+			name.push_back(c);
 		}
-		name.AddCpy('\0');
-		shdr_name_arr.push_back(std::string(name.GetPtr()));	
+		shdr_name_arr.push_back(name);
 	}
 
 	return true;
@@ -204,7 +206,7 @@ bool ELF32Loader::LoadPhdrData(u64 _offset)
 {
 	const u64 offset = machine == MACHINE_SPU ? _offset : 0;
 
-	for(u32 i=0; i<phdr_arr.GetCount(); ++i)
+	for(u32 i=0; i<phdr_arr.size(); ++i)
 	{
 		phdr_arr[i].Show();
 
@@ -294,12 +296,12 @@ bool ELF32Loader::LoadPhdrData(u64 _offset)
 
 bool ELF32Loader::LoadShdrData(u64 offset)
 {
-	for(u32 i=0; i<shdr_arr.GetCount(); ++i)
+	for(u32 i=0; i<shdr_arr.size(); ++i)
 	{
 		Elf32_Shdr& shdr = shdr_arr[i];
 
 #ifdef LOADER_DEBUG
-		if(i < shdr_name_arr.GetCount()) ConLog.Write("Name: %s", shdr_name_arr[i].c_str());
+		if(i < shdr_name_arr.size()) ConLog.Write("Name: %s", shdr_name_arr[i].c_str());
 		shdr.Show();
 		ConLog.SkipLn();
 #endif
@@ -323,4 +325,4 @@ bool ELF32Loader::LoadShdrData(u64 offset)
 
 	//TODO
 	return true;
-}
\ No newline at end of file
+}
diff --git a/rpcs3/Loader/ELF32.h b/rpcs3/Loader/ELF32.h
index 62fa2d1583..5882d3ffea 100644
--- a/rpcs3/Loader/ELF32.h
+++ b/rpcs3/Loader/ELF32.h
@@ -287,8 +287,8 @@ class ELF32Loader : public LoaderBase
 public:
 	Elf32_Ehdr ehdr;
 	std::vector<std::string> shdr_name_arr;
-	Array<Elf32_Shdr> shdr_arr;
-	Array<Elf32_Phdr> phdr_arr;
+	std::vector<Elf32_Shdr> shdr_arr;
+	std::vector<Elf32_Phdr> phdr_arr;
 
 	ELF32Loader(vfsStream& f);
 	~ELF32Loader() {Close();}
@@ -309,4 +309,4 @@ private:
 
 void WriteEhdr(wxFile& f, Elf32_Ehdr& ehdr);
 void WritePhdr(wxFile& f, Elf32_Phdr& phdr);
-void WriteShdr(wxFile& f, Elf32_Shdr& shdr);
\ No newline at end of file
+void WriteShdr(wxFile& f, Elf32_Shdr& shdr);
diff --git a/rpcs3/Loader/ELF64.cpp b/rpcs3/Loader/ELF64.cpp
index 2093b89790..665ec21019 100644
--- a/rpcs3/Loader/ELF64.cpp
+++ b/rpcs3/Loader/ELF64.cpp
@@ -129,7 +129,7 @@ bool ELF64Loader::LoadEhdrInfo(s64 offset)
 
 bool ELF64Loader::LoadPhdrInfo(s64 offset)
 {
-	phdr_arr.Clear();
+	phdr_arr.clear();
 
 	if(ehdr.e_phoff == 0 && ehdr.e_phnum)
 	{
@@ -141,9 +141,8 @@ bool ELF64Loader::LoadPhdrInfo(s64 offset)
 
 	for(u32 i=0; i<ehdr.e_phnum; ++i)
 	{
-		Elf64_Phdr* phdr = new Elf64_Phdr();
-		phdr->Load(elf64_f);
-		phdr_arr.Move(phdr);
+		phdr_arr.emplace_back();
+		phdr_arr.back().Load(elf64_f);
 	}
 
 	return true;
@@ -151,7 +150,7 @@ bool ELF64Loader::LoadPhdrInfo(s64 offset)
 
 bool ELF64Loader::LoadShdrInfo(s64 offset)
 {
-	shdr_arr.Clear();
+	shdr_arr.clear();
 	shdr_name_arr.clear();
 	if(ehdr.e_shoff == 0 && ehdr.e_shnum)
 	{
@@ -162,30 +161,28 @@ bool ELF64Loader::LoadShdrInfo(s64 offset)
 	elf64_f.Seek(offset < 0 ? ehdr.e_shoff : offset);
 	for(u32 i=0; i<ehdr.e_shnum; ++i)
 	{
-		Elf64_Shdr* shdr = new Elf64_Shdr();
-		shdr->Load(elf64_f);
-		shdr_arr.Move(shdr);
+		shdr_arr.emplace_back();
+		shdr_arr.back().Load(elf64_f);
 	}
 
-	if(ehdr.e_shstrndx >= shdr_arr.GetCount())
+	if(ehdr.e_shstrndx >= shdr_arr.size())
 	{
 		ConLog.Warning("LoadShdr64 error: shstrndx too big!");
 		return true;
 	}
 
-	for(u32 i=0; i<shdr_arr.GetCount(); ++i)
+	for(u32 i=0; i<shdr_arr.size(); ++i)
 	{
 		elf64_f.Seek((offset < 0 ? shdr_arr[ehdr.e_shstrndx].sh_offset : shdr_arr[ehdr.e_shstrndx].sh_offset - ehdr.e_shoff + offset) + shdr_arr[i].sh_name);
-		Array<char> name;
+		std::string name;
 		while(!elf64_f.Eof())
 		{
 			char c;
 			elf64_f.Read(&c, 1);
 			if(c == 0) break;
-			name.AddCpy(c);
+			name.push_back(c);
 		}
-		name.AddCpy('\0');
-		shdr_name_arr.push_back(std::string(name.GetPtr()));
+		shdr_name_arr.push_back(name);
 	}
 
 	return true;
@@ -203,7 +200,7 @@ bool ELF64Loader::LoadEhdrData(u64 offset)
 
 bool ELF64Loader::LoadPhdrData(u64 offset)
 {
-	for(u32 i=0; i<phdr_arr.GetCount(); ++i)
+	for(u32 i=0; i<phdr_arr.size(); ++i)
 	{
 		phdr_arr[i].Show();
 
@@ -411,7 +408,7 @@ bool ELF64Loader::LoadShdrData(u64 offset)
 {
 	u64 max_addr = 0;
 
-	for(uint i=0; i<shdr_arr.GetCount(); ++i)
+	for(uint i=0; i<shdr_arr.size(); ++i)
 	{
 		Elf64_Shdr& shdr = shdr_arr[i];
 
diff --git a/rpcs3/Loader/ELF64.h b/rpcs3/Loader/ELF64.h
index b8be844a6e..fc8005b5ef 100644
--- a/rpcs3/Loader/ELF64.h
+++ b/rpcs3/Loader/ELF64.h
@@ -164,8 +164,8 @@ class ELF64Loader : public LoaderBase
 public:
 	Elf64_Ehdr ehdr;
 	std::vector<std::string> shdr_name_arr;
-	Array<Elf64_Shdr> shdr_arr;
-	Array<Elf64_Phdr> phdr_arr;
+	std::vector<Elf64_Shdr> shdr_arr;
+	std::vector<Elf64_Phdr> phdr_arr;
 
 	ELF64Loader(vfsStream& f);
 	~ELF64Loader() {Close();}
@@ -188,4 +188,4 @@ private:
 
 void WriteEhdr(wxFile& f, Elf64_Ehdr& ehdr);
 void WritePhdr(wxFile& f, Elf64_Phdr& phdr);
-void WriteShdr(wxFile& f, Elf64_Shdr& shdr);
\ No newline at end of file
+void WriteShdr(wxFile& f, Elf64_Shdr& shdr);
diff --git a/rpcs3/Loader/Loader.h b/rpcs3/Loader/Loader.h
index ca69ec408a..e630b7a947 100644
--- a/rpcs3/Loader/Loader.h
+++ b/rpcs3/Loader/Loader.h
@@ -191,6 +191,8 @@ protected:
 	}
 
 public:
+	virtual ~LoaderBase() = default;
+
 	virtual bool LoadInfo() { return false; }
 	virtual bool LoadData(u64 offset = 0) { return false; }
 	Elf_Machine GetMachine() const { return machine; }
@@ -208,7 +210,7 @@ class Loader : public LoaderBase
 public:
 	Loader();
 	Loader(vfsFileBase& stream);
-	~Loader();
+	virtual ~Loader();
 
 	void Open(const std::string& path);
 	void Open(vfsFileBase& stream);
diff --git a/rpcs3/Loader/TROPUSR.cpp b/rpcs3/Loader/TROPUSR.cpp
index 738e00ca46..756b9366eb 100644
--- a/rpcs3/Loader/TROPUSR.cpp
+++ b/rpcs3/Loader/TROPUSR.cpp
@@ -28,8 +28,7 @@ bool TROPUSRLoader::Load(const std::string& filepath, const std::string& configp
 	LoadTableHeaders();
 	LoadTables();
 
-	m_file->Close();
-	m_file = NULL;
+	Close();
 	return true;
 }
 
@@ -206,7 +205,7 @@ bool TROPUSRLoader::Close()
 {
 	if (m_file && m_file->Close())
 	{
-		m_file = NULL;
+		safe_delete(m_file);
 		return true;
 	}
 	return false;
diff --git a/rpcs3/rpcs3.vcxproj b/rpcs3/rpcs3.vcxproj
index aa8bf61a22..6d4a66dbff 100644
--- a/rpcs3/rpcs3.vcxproj
+++ b/rpcs3/rpcs3.vcxproj
@@ -1,6 +1,14 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug - MemLeak|Win32">
+      <Configuration>Debug - MemLeak</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug - MemLeak|x64">
+      <Configuration>Debug - MemLeak</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
       <Platform>Win32</Platform>
@@ -30,12 +38,24 @@
     <CharacterSet>Unicode</CharacterSet>
     <PlatformToolset>v120</PlatformToolset>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <CharacterSet>Unicode</CharacterSet>
     <PlatformToolset>v120</PlatformToolset>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
@@ -58,9 +78,15 @@
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
@@ -74,12 +100,24 @@
     <LibraryPath>..\libs\$(Configuration)\;$(LibraryPath)</LibraryPath>
     <TargetName>$(ProjectName)-$(PlatformShortName)-dbg</TargetName>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|Win32'">
+    <IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86\Include;.\OpenAL\include;$(IncludePath)</IncludePath>
+    <OutDir>$(SolutionDir)bin\</OutDir>
+    <LibraryPath>..\libs\$(Configuration)\;$(LibraryPath)</LibraryPath>
+    <TargetName>$(ProjectName)-$(PlatformShortName)-dbg</TargetName>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit</IncludePath>
     <OutDir>$(SolutionDir)bin\</OutDir>
     <LibraryPath>..\libs\$(Configuration)\;$(LibraryPath)</LibraryPath>
     <TargetName>$(ProjectName)-$(PlatformShortName)-dbg</TargetName>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|x64'">
+    <IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86_64\Include;.\OpenAL\include;$(IncludePath)</IncludePath>
+    <OutDir>$(SolutionDir)bin\</OutDir>
+    <LibraryPath>..\libs\$(Configuration)\;$(LibraryPath)</LibraryPath>
+    <TargetName>$(ProjectName)-$(PlatformShortName)-dbg</TargetName>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>.\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;..\ffmpeg\WindowsInclude;..\ffmpeg\Windows\x86\Include;.\OpenAL\include;$(IncludePath);..\asmjit\src\asmjit</IncludePath>
@@ -119,6 +157,27 @@
       </Command>
     </PreBuildEvent>
   </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <BufferSecurityCheck>true</BufferSecurityCheck>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>wxmsw31ud_adv.lib;wxbase31ud.lib;wxmsw31ud_core.lib;wxmsw31ud_aui.lib;wxtiffd.lib;wxjpegd.lib;wxpngd.lib;wxzlibd.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;avcodec.lib;avformat.lib;avutil.lib;swresample.lib;swscale.lib;OpenAL32.lib;EFX-Util.lib;asmjit.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <DataExecutionPrevention>false</DataExecutionPrevention>
+      <AdditionalLibraryDirectories>..\wxWidgets\lib\vc_lib;..\ffmpeg\Windows\x86\lib;..\OpenAL\Win32</AdditionalLibraryDirectories>
+    </Link>
+    <PreBuildEvent>
+      <Command>
+      </Command>
+    </PreBuildEvent>
+  </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
@@ -141,6 +200,29 @@
       <UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
     </ProjectReference>
   </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <AdditionalIncludeDirectories>..\wxWidgets\include\msvc</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>_UNICODE;UNICODE;MSVC_CRT_MEMLEAK_DETECTION;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>wxmsw31ud_adv.lib;wxbase31ud.lib;wxmsw31ud_core.lib;wxmsw31ud_aui.lib;wxtiffd.lib;wxjpegd.lib;wxpngd.lib;wxzlibd.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;avcodec.lib;avformat.lib;avutil.lib;swresample.lib;swscale.lib;OpenAL32.lib;EFX-Util.lib;asmjit.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <DataExecutionPrevention>false</DataExecutionPrevention>
+      <AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories>
+    </Link>
+    <PreBuildEvent>
+      <Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command>
+    </PreBuildEvent>
+    <ProjectReference>
+      <UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
+    </ProjectReference>
+  </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <WarningLevel>TurnOffAllWarnings</WarningLevel>
@@ -161,7 +243,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>wxmsw31u_adv.lib;wxbase31u.lib;wxmsw31u_core.lib;wxmsw31u_aui.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;wxtiff.lib;wxjpeg.lib;wxpng.lib;wxzlib.lib;wxregexu.lib;wxexpat.lib;wsock32.lib;wininet.lib;avcodec.lib;avformat.lib;avutil.lib;swresample.lib;swscale.lib;OpenAL32.lib;EFX-Util.lib;asmjit.lib</AdditionalDependencies>
+      <AdditionalDependencies>wxmsw31u_adv.lib;wxbase31u.lib;wxmsw31u_core.lib;wxmsw31u_aui.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;wxtiff.lib;wxjpeg.lib;wxpng.lib;wxzlib.lib;wxregexu.lib;wxexpat.lib;wsock32.lib;wininet.lib;avcodec.lib;avformat.lib;avutil.lib;swresample.lib;swscale.lib;OpenAL32.lib;EFX-Util.lib;asmjit.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <IgnoreAllDefaultLibraries>
       </IgnoreAllDefaultLibraries>
       <IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
@@ -187,6 +269,7 @@
       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
       <ExceptionHandling>Sync</ExceptionHandling>
       <EnablePREfast>false</EnablePREfast>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -353,7 +436,9 @@
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|Win32'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|x64'">Create</PrecompiledHeader>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
@@ -401,6 +486,7 @@
     <ClInclude Include="Emu\Cell\RawSPUThread.h" />
     <ClInclude Include="Emu\Cell\SPUDecoder.h" />
     <ClInclude Include="Emu\Cell\SPUDisAsm.h" />
+    <ClInclude Include="Emu\Cell\SPUInstrTable.h" />
     <ClInclude Include="Emu\Cell\SPUInterpreter.h" />
     <ClInclude Include="Emu\Cell\SPUOpcodes.h" />
     <ClInclude Include="Emu\Cell\SPURecompiler.h" />
diff --git a/rpcs3/rpcs3.vcxproj.filters b/rpcs3/rpcs3.vcxproj.filters
index 8574f6f5e4..e5adadf067 100644
--- a/rpcs3/rpcs3.vcxproj.filters
+++ b/rpcs3/rpcs3.vcxproj.filters
@@ -984,5 +984,8 @@
     <ClInclude Include="Emu\Cell\SPURecompiler.h">
       <Filter>Emu\Cell</Filter>
     </ClInclude>
+    <ClInclude Include="Emu\Cell\SPUInstrTable.h">
+      <Filter>Emu\Cell</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/rpcs3/rpcs3.vcxproj.user b/rpcs3/rpcs3.vcxproj.user
index d7fe813d8f..b03467fb6a 100644
--- a/rpcs3/rpcs3.vcxproj.user
+++ b/rpcs3/rpcs3.vcxproj.user
@@ -4,6 +4,10 @@
     <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\</LocalDebuggerWorkingDirectory>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|x64'">
+    <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\</LocalDebuggerWorkingDirectory>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\</LocalDebuggerWorkingDirectory>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
@@ -12,8 +16,15 @@
     <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\</LocalDebuggerWorkingDirectory>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|Win32'">
+    <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\</LocalDebuggerWorkingDirectory>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LocalDebuggerWorkingDirectory>$(SolutionDir)bin\</LocalDebuggerWorkingDirectory>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
   </PropertyGroup>
+  <PropertyGroup>
+    <ShowAllFiles>false</ShowAllFiles>
+  </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/rpcs3/stdafx.h b/rpcs3/stdafx.h
index a039b04acf..b8492794c4 100644
--- a/rpcs3/stdafx.h
+++ b/rpcs3/stdafx.h
@@ -1,5 +1,11 @@
 #pragma once
 
+#ifdef MSVC_CRT_MEMLEAK_DETECTION
+	#define _CRTDBG_MAP_ALLOC
+	#include <stdlib.h>
+	#include <crtdbg.h>
+#endif
+
 #define NOMINMAX
 
 #ifndef QT_UI
@@ -34,6 +40,15 @@
 #include <wx/wxprec.h>
 #endif
 
+#ifdef MSVC_CRT_MEMLEAK_DETECTION
+	#ifdef _DEBUG
+		#ifndef DBG_NEW
+			#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
+			#define new DBG_NEW
+		#endif
+	#endif  // _DEBUG
+#endif // MSVC_CRT_MEMLEAK_DETECTION
+
 #ifndef _WIN32
 //hack, disabled
 //#define wx_str() ToStdString().c_str()
@@ -273,6 +288,7 @@ enum Status
 #include "Emu/Memory/Memory.h"
 #include "Emu/System.h"
 #include "Emu/Cell/PPUThread.h"
+#include "Emu/SysCalls/SC_FUNC.h"
 #include "Emu/SysCalls/Modules.h"
 
 
diff --git a/wxWidgets b/wxWidgets
index 6637946d55..143b52a764 160000
--- a/wxWidgets
+++ b/wxWidgets
@@ -1 +1 @@
-Subproject commit 6637946d55f41e8615c09fd202c6399017916e2b
+Subproject commit 143b52a7645b140dff414f332b97f00444332bb9