Reformat all the things. Have fun with merge conflicts.

1 files changed, 348 insertions, 341 deletions

diff --git a/Source/Core/DiscIO/NANDContentLoader.cpp b/Source/Core/DiscIO/NANDContentLoader.cpp
index b7f5deb9c1..36f672b026 100644
--- a/Source/Core/DiscIO/NANDContentLoader.cpp
+++ b/Source/Core/DiscIO/NANDContentLoader.cpp
@@ -9,19 +9,19 @@
 #include <cstring>
 #include <functional>
 #include <map>
+#include <mbedtls/aes.h>
 #include <string>
 #include <utility>
 #include <vector>
-#include <mbedtls/aes.h>
 
 #include "Common/CommonFuncs.h"
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
+#include "Common/Logging/Log.h"
 #include "Common/MathUtil.h"
 #include "Common/MsgHandler.h"
 #include "Common/NandPaths.h"
 #include "Common/StringUtil.h"
-#include "Common/Logging/Log.h"
 
 #include "DiscIO/NANDContentLoader.h"
 #include "DiscIO/Volume.h"
@@ -29,132 +29,129 @@
 
 namespace DiscIO
 {
-
 CSharedContent::CSharedContent()
 {
-	UpdateLocation();
+  UpdateLocation();
 }
 
 void CSharedContent::UpdateLocation()
 {
-	m_Elements.clear();
-	m_LastID = 0;
-	m_ContentMap = StringFromFormat("%s/shared1/content.map", File::GetUserPath(D_WIIROOT_IDX).c_str());
-
-	File::IOFile pFile(m_ContentMap, "rb");
-	SElement Element;
-	while (pFile.ReadArray(&Element, 1))
-	{
-		m_Elements.push_back(Element);
-		m_LastID++;
-	}
+  m_Elements.clear();
+  m_LastID = 0;
+  m_ContentMap =
+      StringFromFormat("%s/shared1/content.map", File::GetUserPath(D_WIIROOT_IDX).c_str());
+
+  File::IOFile pFile(m_ContentMap, "rb");
+  SElement Element;
+  while (pFile.ReadArray(&Element, 1))
+  {
+    m_Elements.push_back(Element);
+    m_LastID++;
+  }
 }
 
 CSharedContent::~CSharedContent()
-{}
+{
+}
 
 std::string CSharedContent::GetFilenameFromSHA1(const u8* hash)
 {
-	for (auto& Element : m_Elements)
-	{
-		if (memcmp(hash, Element.SHA1Hash, 20) == 0)
-		{
-			return StringFromFormat("%s/shared1/%c%c%c%c%c%c%c%c.app", File::GetUserPath(D_WIIROOT_IDX).c_str(),
-			    Element.FileName[0], Element.FileName[1], Element.FileName[2], Element.FileName[3],
-			    Element.FileName[4], Element.FileName[5], Element.FileName[6], Element.FileName[7]);
-		}
-	}
-	return "unk";
+  for (auto& Element : m_Elements)
+  {
+    if (memcmp(hash, Element.SHA1Hash, 20) == 0)
+    {
+      return StringFromFormat(
+          "%s/shared1/%c%c%c%c%c%c%c%c.app", File::GetUserPath(D_WIIROOT_IDX).c_str(),
+          Element.FileName[0], Element.FileName[1], Element.FileName[2], Element.FileName[3],
+          Element.FileName[4], Element.FileName[5], Element.FileName[6], Element.FileName[7]);
+    }
+  }
+  return "unk";
 }
 
 std::string CSharedContent::AddSharedContent(const u8* hash)
 {
-	std::string filename = GetFilenameFromSHA1(hash);
+  std::string filename = GetFilenameFromSHA1(hash);
 
-	if (strcasecmp(filename.c_str(), "unk") == 0)
-	{
-		std::string id = StringFromFormat("%08x", m_LastID);
-		SElement Element;
-		memcpy(Element.FileName, id.c_str(), 8);
-		memcpy(Element.SHA1Hash, hash, 20);
-		m_Elements.push_back(Element);
+  if (strcasecmp(filename.c_str(), "unk") == 0)
+  {
+    std::string id = StringFromFormat("%08x", m_LastID);
+    SElement Element;
+    memcpy(Element.FileName, id.c_str(), 8);
+    memcpy(Element.SHA1Hash, hash, 20);
+    m_Elements.push_back(Element);
 
-		File::CreateFullPath(m_ContentMap);
+    File::CreateFullPath(m_ContentMap);
 
-		File::IOFile pFile(m_ContentMap, "ab");
-		pFile.WriteArray(&Element, 1);
+    File::IOFile pFile(m_ContentMap, "ab");
+    pFile.WriteArray(&Element, 1);
 
-		filename = StringFromFormat("%s/shared1/%s.app", File::GetUserPath(D_WIIROOT_IDX).c_str(), id.c_str());
-		m_LastID++;
-	}
+    filename =
+        StringFromFormat("%s/shared1/%s.app", File::GetUserPath(D_WIIROOT_IDX).c_str(), id.c_str());
+    m_LastID++;
+  }
 
-	return filename;
+  return filename;
 }
 
 void CNANDContentDataFile::EnsureOpen()
 {
-	if (!m_file)
-		m_file = std::make_unique<File::IOFile>(m_filename, "rb");
-	else if (!m_file->IsOpen())
-		m_file->Open(m_filename, "rb");
+  if (!m_file)
+    m_file = std::make_unique<File::IOFile>(m_filename, "rb");
+  else if (!m_file->IsOpen())
+    m_file->Open(m_filename, "rb");
 }
 void CNANDContentDataFile::Open()
 {
-	EnsureOpen();
+  EnsureOpen();
 }
 const std::vector<u8> CNANDContentDataFile::Get()
 {
-	std::vector<u8> result;
-	EnsureOpen();
-	if (!m_file->IsGood())
-		return result;
+  std::vector<u8> result;
+  EnsureOpen();
+  if (!m_file->IsGood())
+    return result;
 
-	u64 size = m_file->GetSize();
-	if (size == 0)
-		return result;
+  u64 size = m_file->GetSize();
+  if (size == 0)
+    return result;
 
-	result.resize(size);
-	m_file->ReadBytes(result.data(), result.size());
+  result.resize(size);
+  m_file->ReadBytes(result.data(), result.size());
 
-	return result;
+  return result;
 }
 
 bool CNANDContentDataFile::GetRange(u32 start, u32 size, u8* buffer)
 {
-	EnsureOpen();
-	if (!m_file->IsGood())
-		return false;
+  EnsureOpen();
+  if (!m_file->IsGood())
+    return false;
 
-	if (!m_file->Seek(start, SEEK_SET))
-		return false;
+  if (!m_file->Seek(start, SEEK_SET))
+    return false;
 
-	return m_file->ReadBytes(buffer, static_cast<size_t>(size));
+  return m_file->ReadBytes(buffer, static_cast<size_t>(size));
 }
 void CNANDContentDataFile::Close()
 {
-	if (m_file && m_file->IsOpen())
-		m_file->Close();
+  if (m_file && m_file->IsOpen())
+    m_file->Close();
 }
 
-
 bool CNANDContentDataBuffer::GetRange(u32 start, u32 size, u8* buffer)
 {
-	if (start + size > m_buffer.size())
-		return false;
+  if (start + size > m_buffer.size())
+    return false;
 
-	std::copy(&m_buffer[start], &m_buffer[start + size], buffer);
-	return true;
+  std::copy(&m_buffer[start], &m_buffer[start + size], buffer);
+  return true;
 }
 
-
 CNANDContentLoader::CNANDContentLoader(const std::string& content_name)
-	: m_Valid(false)
-	, m_IsWAD(false)
-	, m_TitleID(-1)
-	, m_IosVersion(0x09)
-	, m_BootIndex(-1)
+    : m_Valid(false), m_IsWAD(false), m_TitleID(-1), m_IosVersion(0x09), m_BootIndex(-1)
 {
-	m_Valid = Initialize(content_name);
+  m_Valid = Initialize(content_name);
 }
 
 CNANDContentLoader::~CNANDContentLoader()
@@ -163,363 +160,373 @@ CNANDContentLoader::~CNANDContentLoader()
 
 const SNANDContent* CNANDContentLoader::GetContentByIndex(int index) const
 {
-	for (auto& Content : m_Content)
-	{
-		if (Content.m_Index == index)
-		{
-			return &Content;
-		}
-	}
-	return nullptr;
+  for (auto& Content : m_Content)
+  {
+    if (Content.m_Index == index)
+    {
+      return &Content;
+    }
+  }
+  return nullptr;
 }
 
 bool CNANDContentLoader::Initialize(const std::string& name)
 {
-	if (name.empty())
-		return false;
-
-	m_Path = name;
-
-	WiiWAD wad(name);
-	std::vector<u8> data_app;
-	std::vector<u8> tmd;
-	std::vector<u8> decrypted_title_key;
-
-	if (wad.IsValid())
-	{
-		m_IsWAD = true;
-		m_Ticket = wad.GetTicket();
-		decrypted_title_key = GetKeyFromTicket(m_Ticket);
-		tmd = wad.GetTMD();
-		data_app = wad.GetDataApp();
-	}
-	else
-	{
-		std::string tmd_filename(m_Path);
-
-		if (tmd_filename.back() == '/')
-			tmd_filename += "title.tmd";
-		else
-			m_Path = tmd_filename.substr(0, tmd_filename.find("title.tmd"));
-
-		File::IOFile tmd_file(tmd_filename, "rb");
-		if (!tmd_file)
-		{
-			WARN_LOG(DISCIO, "CreateFromDirectory: error opening %s", tmd_filename.c_str());
-			return false;
-		}
-
-		tmd.resize(static_cast<size_t>(File::GetSize(tmd_filename)));
-		tmd_file.ReadBytes(tmd.data(), tmd.size());
-	}
-
-	std::copy(&tmd[0],     &tmd[TMD_HEADER_SIZE], m_TMDHeader);
-	std::copy(&tmd[0x180], &tmd[0x180 + TMD_VIEW_SIZE], m_TMDView);
-
-	m_TitleVersion = Common::swap16(&tmd[0x01DC]);
-	m_NumEntries   = Common::swap16(&tmd[0x01DE]);
-	m_BootIndex    = Common::swap16(&tmd[0x01E0]);
-	m_TitleID      = Common::swap64(&tmd[0x018C]);
-	m_IosVersion   = Common::swap16(&tmd[0x018A]);
-	m_Country      = static_cast<u8>(m_TitleID & 0xFF);
-
-	if (m_Country == 2) // SYSMENU
-		m_Country = GetSysMenuRegion(m_TitleVersion);
-
-	InitializeContentEntries(tmd, decrypted_title_key, data_app);
-	return true;
+  if (name.empty())
+    return false;
+
+  m_Path = name;
+
+  WiiWAD wad(name);
+  std::vector<u8> data_app;
+  std::vector<u8> tmd;
+  std::vector<u8> decrypted_title_key;
+
+  if (wad.IsValid())
+  {
+    m_IsWAD = true;
+    m_Ticket = wad.GetTicket();
+    decrypted_title_key = GetKeyFromTicket(m_Ticket);
+    tmd = wad.GetTMD();
+    data_app = wad.GetDataApp();
+  }
+  else
+  {
+    std::string tmd_filename(m_Path);
+
+    if (tmd_filename.back() == '/')
+      tmd_filename += "title.tmd";
+    else
+      m_Path = tmd_filename.substr(0, tmd_filename.find("title.tmd"));
+
+    File::IOFile tmd_file(tmd_filename, "rb");
+    if (!tmd_file)
+    {
+      WARN_LOG(DISCIO, "CreateFromDirectory: error opening %s", tmd_filename.c_str());
+      return false;
+    }
+
+    tmd.resize(static_cast<size_t>(File::GetSize(tmd_filename)));
+    tmd_file.ReadBytes(tmd.data(), tmd.size());
+  }
+
+  std::copy(&tmd[0], &tmd[TMD_HEADER_SIZE], m_TMDHeader);
+  std::copy(&tmd[0x180], &tmd[0x180 + TMD_VIEW_SIZE], m_TMDView);
+
+  m_TitleVersion = Common::swap16(&tmd[0x01DC]);
+  m_NumEntries = Common::swap16(&tmd[0x01DE]);
+  m_BootIndex = Common::swap16(&tmd[0x01E0]);
+  m_TitleID = Common::swap64(&tmd[0x018C]);
+  m_IosVersion = Common::swap16(&tmd[0x018A]);
+  m_Country = static_cast<u8>(m_TitleID & 0xFF);
+
+  if (m_Country == 2)  // SYSMENU
+    m_Country = GetSysMenuRegion(m_TitleVersion);
+
+  InitializeContentEntries(tmd, decrypted_title_key, data_app);
+  return true;
 }
 
-void CNANDContentLoader::InitializeContentEntries(const std::vector<u8>& tmd, const std::vector<u8>& decrypted_title_key, const std::vector<u8>& data_app)
+void CNANDContentLoader::InitializeContentEntries(const std::vector<u8>& tmd,
+                                                  const std::vector<u8>& decrypted_title_key,
+                                                  const std::vector<u8>& data_app)
 {
-	m_Content.resize(m_NumEntries);
+  m_Content.resize(m_NumEntries);
 
-	std::array<u8, 16> iv;
-	u32 data_app_offset = 0;
+  std::array<u8, 16> iv;
+  u32 data_app_offset = 0;
 
-	for (u32 i = 0; i < m_NumEntries; i++)
-	{
-		const u32 entry_offset = 0x24 * i;
+  for (u32 i = 0; i < m_NumEntries; i++)
+  {
+    const u32 entry_offset = 0x24 * i;
 
-		SNANDContent& content = m_Content[i];
-		content.m_ContentID = Common::swap32(&tmd[entry_offset + 0x01E4]);
-		content.m_Index     = Common::swap16(&tmd[entry_offset + 0x01E8]);
-		content.m_Type      = Common::swap16(&tmd[entry_offset + 0x01EA]);
-		content.m_Size      = static_cast<u32>(Common::swap64(&tmd[entry_offset + 0x01EC]));
+    SNANDContent& content = m_Content[i];
+    content.m_ContentID = Common::swap32(&tmd[entry_offset + 0x01E4]);
+    content.m_Index = Common::swap16(&tmd[entry_offset + 0x01E8]);
+    content.m_Type = Common::swap16(&tmd[entry_offset + 0x01EA]);
+    content.m_Size = static_cast<u32>(Common::swap64(&tmd[entry_offset + 0x01EC]));
 
-		const auto header_begin = std::next(tmd.begin(), entry_offset + 0x01E4);
-		const auto header_end   = std::next(header_begin, ArraySize(content.m_Header));
-		std::copy(header_begin, header_end, content.m_Header);
+    const auto header_begin = std::next(tmd.begin(), entry_offset + 0x01E4);
+    const auto header_end = std::next(header_begin, ArraySize(content.m_Header));
+    std::copy(header_begin, header_end, content.m_Header);
 
-		const auto hash_begin = std::next(tmd.begin(), entry_offset + 0x01F4);
-		const auto hash_end   = std::next(hash_begin, ArraySize(content.m_SHA1Hash));
-		std::copy(hash_begin, hash_end, content.m_SHA1Hash);
+    const auto hash_begin = std::next(tmd.begin(), entry_offset + 0x01F4);
+    const auto hash_end = std::next(hash_begin, ArraySize(content.m_SHA1Hash));
+    std::copy(hash_begin, hash_end, content.m_SHA1Hash);
 
-		if (m_IsWAD)
-		{
-			u32 rounded_size = ROUND_UP(content.m_Size, 0x40);
+    if (m_IsWAD)
+    {
+      u32 rounded_size = ROUND_UP(content.m_Size, 0x40);
 
-			iv.fill(0);
-			std::copy(&tmd[entry_offset + 0x01E8], &tmd[entry_offset + 0x01E8 + 2], iv.begin());
+      iv.fill(0);
+      std::copy(&tmd[entry_offset + 0x01E8], &tmd[entry_offset + 0x01E8 + 2], iv.begin());
 
-			content.m_Data = std::make_unique<CNANDContentDataBuffer>(AESDecode(decrypted_title_key.data(), iv.data(), &data_app[data_app_offset], rounded_size));
+      content.m_Data = std::make_unique<CNANDContentDataBuffer>(AESDecode(
+          decrypted_title_key.data(), iv.data(), &data_app[data_app_offset], rounded_size));
 
-			data_app_offset += rounded_size;
-			continue;
-		}
+      data_app_offset += rounded_size;
+      continue;
+    }
 
-		std::string filename;
-		if (content.m_Type & 0x8000)  // shared app
-			filename = CSharedContent::AccessInstance().GetFilenameFromSHA1(content.m_SHA1Hash);
-		else
-			filename = StringFromFormat("%s/%08x.app", m_Path.c_str(), content.m_ContentID);
+    std::string filename;
+    if (content.m_Type & 0x8000)  // shared app
+      filename = CSharedContent::AccessInstance().GetFilenameFromSHA1(content.m_SHA1Hash);
+    else
+      filename = StringFromFormat("%s/%08x.app", m_Path.c_str(), content.m_ContentID);
 
-		content.m_Data = std::make_unique<CNANDContentDataFile>(filename);
+    content.m_Data = std::make_unique<CNANDContentDataFile>(filename);
 
-		// Be graceful about incorrect TMDs.
-		if (File::Exists(filename))
-			content.m_Size = static_cast<u32>(File::GetSize(filename));
-	}
+    // Be graceful about incorrect TMDs.
+    if (File::Exists(filename))
+      content.m_Size = static_cast<u32>(File::GetSize(filename));
+  }
 }
 
 std::vector<u8> CNANDContentLoader::AESDecode(const u8* key, u8* iv, const u8* src, u32 size)
 {
-	mbedtls_aes_context aes_ctx;
-	std::vector<u8> buffer(size);
+  mbedtls_aes_context aes_ctx;
+  std::vector<u8> buffer(size);
 
-	mbedtls_aes_setkey_dec(&aes_ctx, key, 128);
-	mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_DECRYPT, size, iv, src, buffer.data());
+  mbedtls_aes_setkey_dec(&aes_ctx, key, 128);
+  mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_DECRYPT, size, iv, src, buffer.data());
 
-	return buffer;
+  return buffer;
 }
 
 std::vector<u8> CNANDContentLoader::GetKeyFromTicket(const std::vector<u8>& ticket)
 {
-	const u8 common_key[16] = {0xeb,0xe4,0x2a,0x22,0x5e,0x85,0x93,0xe4,0x48,0xd9,0xc5,0x45,0x73,0x81,0xaa,0xf7};
-	u8 iv[16] = {};
+  const u8 common_key[16] = {0xeb, 0xe4, 0x2a, 0x22, 0x5e, 0x85, 0x93, 0xe4,
+                             0x48, 0xd9, 0xc5, 0x45, 0x73, 0x81, 0xaa, 0xf7};
+  u8 iv[16] = {};
 
-	std::copy(&ticket[0x01DC], &ticket[0x01DC + 8], iv);
-	return AESDecode(common_key, iv, &ticket[0x01BF], 16);
+  std::copy(&ticket[0x01DC], &ticket[0x01DC + 8], iv);
+  return AESDecode(common_key, iv, &ticket[0x01BF], 16);
 }
 
-
 DiscIO::IVolume::ECountry CNANDContentLoader::GetCountry() const
 {
-	if (!IsValid())
-		return DiscIO::IVolume::COUNTRY_UNKNOWN;
+  if (!IsValid())
+    return DiscIO::IVolume::COUNTRY_UNKNOWN;
 
-	return CountrySwitch(m_Country);
+  return CountrySwitch(m_Country);
 }
 
-
 CNANDContentManager::~CNANDContentManager()
 {
 }
 
 const CNANDContentLoader& CNANDContentManager::GetNANDLoader(const std::string& content_path)
 {
-	auto it = m_map.find(content_path);
-	if (it != m_map.end())
-		return *it->second;
-	return *m_map.emplace_hint(it, std::make_pair(content_path, std::make_unique<CNANDContentLoader>(content_path)))->second;
+  auto it = m_map.find(content_path);
+  if (it != m_map.end())
+    return *it->second;
+  return *m_map
+              .emplace_hint(it, std::make_pair(content_path,
+                                               std::make_unique<CNANDContentLoader>(content_path)))
+              ->second;
 }
 
-const CNANDContentLoader& CNANDContentManager::GetNANDLoader(u64 title_id, Common::FromWhichRoot from)
+const CNANDContentLoader& CNANDContentManager::GetNANDLoader(u64 title_id,
+                                                             Common::FromWhichRoot from)
 {
-	std::string path = Common::GetTitleContentPath(title_id, from);
-	return GetNANDLoader(path);
+  std::string path = Common::GetTitleContentPath(title_id, from);
+  return GetNANDLoader(path);
 }
 
 bool CNANDContentManager::RemoveTitle(u64 title_id, Common::FromWhichRoot from)
 {
-	auto& loader = GetNANDLoader(title_id, from);
-	if (!loader.IsValid())
-		return false;
-	loader.RemoveTitle();
-	return GetNANDLoader(title_id, from).IsValid();
+  auto& loader = GetNANDLoader(title_id, from);
+  if (!loader.IsValid())
+    return false;
+  loader.RemoveTitle();
+  return GetNANDLoader(title_id, from).IsValid();
 }
 
 void CNANDContentManager::ClearCache()
 {
-	m_map.clear();
+  m_map.clear();
 }
 
 void CNANDContentLoader::RemoveTitle() const
 {
-	INFO_LOG(DISCIO, "RemoveTitle %08x/%08x", (u32)(m_TitleID >> 32), (u32)m_TitleID);
-	if (IsValid())
-	{
-		// remove TMD?
-		for (u32 i = 0; i < m_NumEntries; i++)
-		{
-			if (!(m_Content[i].m_Type & 0x8000)) // skip shared apps
-			{
-				std::string filename = StringFromFormat("%s/%08x.app", m_Path.c_str(), m_Content[i].m_ContentID);
-				INFO_LOG(DISCIO, "Delete %s", filename.c_str());
-				File::Delete(filename);
-			}
-		}
-		CNANDContentManager::Access().ClearCache(); // deletes 'this'
-	}
+  INFO_LOG(DISCIO, "RemoveTitle %08x/%08x", (u32)(m_TitleID >> 32), (u32)m_TitleID);
+  if (IsValid())
+  {
+    // remove TMD?
+    for (u32 i = 0; i < m_NumEntries; i++)
+    {
+      if (!(m_Content[i].m_Type & 0x8000))  // skip shared apps
+      {
+        std::string filename =
+            StringFromFormat("%s/%08x.app", m_Path.c_str(), m_Content[i].m_ContentID);
+        INFO_LOG(DISCIO, "Delete %s", filename.c_str());
+        File::Delete(filename);
+      }
+    }
+    CNANDContentManager::Access().ClearCache();  // deletes 'this'
+  }
 }
 
 cUIDsys::cUIDsys()
 {
-	UpdateLocation();
+  UpdateLocation();
 }
 
 void cUIDsys::UpdateLocation()
 {
-	m_Elements.clear();
-	m_LastUID = 0x00001000;
-	m_UidSys = File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/sys/uid.sys";
-
-	File::IOFile pFile(m_UidSys, "rb");
-	SElement Element;
-	while (pFile.ReadArray(&Element, 1))
-	{
-		*(u32*)&(Element.UID) = Common::swap32(m_LastUID++);
-		m_Elements.push_back(Element);
-	}
-	pFile.Close();
-
-	if (m_Elements.empty())
-	{
-		*(u64*)&(Element.titleID) = Common::swap64(TITLEID_SYSMENU);
-		*(u32*)&(Element.UID) = Common::swap32(m_LastUID++);
-
-		File::CreateFullPath(m_UidSys);
-		pFile.Open(m_UidSys, "wb");
-		if (!pFile.WriteArray(&Element, 1))
-			ERROR_LOG(DISCIO, "Failed to write to %s", m_UidSys.c_str());
-	}
+  m_Elements.clear();
+  m_LastUID = 0x00001000;
+  m_UidSys = File::GetUserPath(D_SESSION_WIIROOT_IDX) + "/sys/uid.sys";
+
+  File::IOFile pFile(m_UidSys, "rb");
+  SElement Element;
+  while (pFile.ReadArray(&Element, 1))
+  {
+    *(u32*)&(Element.UID) = Common::swap32(m_LastUID++);
+    m_Elements.push_back(Element);
+  }
+  pFile.Close();
+
+  if (m_Elements.empty())
+  {
+    *(u64*)&(Element.titleID) = Common::swap64(TITLEID_SYSMENU);
+    *(u32*)&(Element.UID) = Common::swap32(m_LastUID++);
+
+    File::CreateFullPath(m_UidSys);
+    pFile.Open(m_UidSys, "wb");
+    if (!pFile.WriteArray(&Element, 1))
+      ERROR_LOG(DISCIO, "Failed to write to %s", m_UidSys.c_str());
+  }
 }
 
 cUIDsys::~cUIDsys()
-{}
+{
+}
 
 u32 cUIDsys::GetUIDFromTitle(u64 title_id)
 {
-	for (auto& Element : m_Elements)
-	{
-		if (Common::swap64(title_id) == *(u64*)&(Element.titleID))
-		{
-			return Common::swap32(Element.UID);
-		}
-	}
-	return 0;
+  for (auto& Element : m_Elements)
+  {
+    if (Common::swap64(title_id) == *(u64*)&(Element.titleID))
+    {
+      return Common::swap32(Element.UID);
+    }
+  }
+  return 0;
 }
 
 void cUIDsys::AddTitle(u64 title_id)
 {
-	if (GetUIDFromTitle(title_id))
-	{
-		INFO_LOG(DISCIO, "Title %08x%08x, already exists in uid.sys", (u32)(title_id >> 32), (u32)title_id);
-		return;
-	}
+  if (GetUIDFromTitle(title_id))
+  {
+    INFO_LOG(DISCIO, "Title %08x%08x, already exists in uid.sys", (u32)(title_id >> 32),
+             (u32)title_id);
+    return;
+  }
 
-	SElement Element;
-	*(u64*)&(Element.titleID) = Common::swap64(title_id);
-	*(u32*)&(Element.UID) = Common::swap32(m_LastUID++);
-	m_Elements.push_back(Element);
+  SElement Element;
+  *(u64*)&(Element.titleID) = Common::swap64(title_id);
+  *(u32*)&(Element.UID) = Common::swap32(m_LastUID++);
+  m_Elements.push_back(Element);
 
-	File::CreateFullPath(m_UidSys);
-	File::IOFile pFile(m_UidSys, "ab");
+  File::CreateFullPath(m_UidSys);
+  File::IOFile pFile(m_UidSys, "ab");
 
-	if (!pFile.WriteArray(&Element, 1))
-		ERROR_LOG(DISCIO, "fwrite failed");
+  if (!pFile.WriteArray(&Element, 1))
+    ERROR_LOG(DISCIO, "fwrite failed");
 }
 
 void cUIDsys::GetTitleIDs(std::vector<u64>& title_ids, bool owned)
 {
-	for (auto& Element : m_Elements)
-	{
-		if ((owned && Common::CheckTitleTIK(Common::swap64(Element.titleID), Common::FROM_SESSION_ROOT))  ||
-			(!owned && Common::CheckTitleTMD(Common::swap64(Element.titleID), Common::FROM_SESSION_ROOT)))
-			title_ids.push_back(Common::swap64(Element.titleID));
-	}
+  for (auto& Element : m_Elements)
+  {
+    if ((owned &&
+         Common::CheckTitleTIK(Common::swap64(Element.titleID), Common::FROM_SESSION_ROOT)) ||
+        (!owned &&
+         Common::CheckTitleTMD(Common::swap64(Element.titleID), Common::FROM_SESSION_ROOT)))
+      title_ids.push_back(Common::swap64(Element.titleID));
+  }
 }
 
 u64 CNANDContentManager::Install_WiiWAD(const std::string& filename)
 {
-	if (filename.find(".wad") == std::string::npos)
-		return 0;
-	const CNANDContentLoader& content_loader = GetNANDLoader(filename);
-	if (content_loader.IsValid() == false)
-		return 0;
-
-	u64 title_id = content_loader.GetTitleID();
-
-	//copy WAD's TMD header and contents to content directory
-
-	std::string content_path(Common::GetTitleContentPath(title_id, Common::FROM_CONFIGURED_ROOT));
-	std::string tmd_filename(Common::GetTMDFileName(title_id, Common::FROM_CONFIGURED_ROOT));
-	File::CreateFullPath(tmd_filename);
-
-	File::IOFile tmd_file(tmd_filename, "wb");
-	if (!tmd_file)
-	{
-		PanicAlertT("WAD installation failed: error creating %s", tmd_filename.c_str());
-		return 0;
-	}
-
-	tmd_file.WriteBytes(content_loader.GetTMDHeader(), CNANDContentLoader::TMD_HEADER_SIZE);
-
-	for (u32 i = 0; i < content_loader.GetContentSize(); i++)
-	{
-		const SNANDContent& content = content_loader.GetContent()[i];
-
-		tmd_file.WriteBytes(content.m_Header, CNANDContentLoader::CONTENT_HEADER_SIZE);
-
-		std::string app_filename;
-		if (content.m_Type & 0x8000) //shared
-			app_filename = CSharedContent::AccessInstance().AddSharedContent(content.m_SHA1Hash);
-		else
-			app_filename = StringFromFormat("%s%08x.app", content_path.c_str(), content.m_ContentID);
-
-		if (!File::Exists(app_filename))
-		{
-			File::CreateFullPath(app_filename);
-			File::IOFile app_file(app_filename, "wb");
-			if (!app_file)
-			{
-				PanicAlertT("WAD installation failed: error creating %s", app_filename.c_str());
-				return 0;
-			}
-
-			app_file.WriteBytes(content.m_Data->Get().data(), content.m_Size);
-		}
-		else
-		{
-			INFO_LOG(DISCIO, "Content %s already exists.", app_filename.c_str());
-		}
-	}
-
-	//Extract and copy WAD's ticket to ticket directory
-	if (!AddTicket(title_id, content_loader.GetTicket()))
-	{
-		PanicAlertT("WAD installation failed: error creating ticket");
-		return 0;
-	}
-
-	cUIDsys::AccessInstance().AddTitle(title_id);
-
-	ClearCache();
-
-	return title_id;
+  if (filename.find(".wad") == std::string::npos)
+    return 0;
+  const CNANDContentLoader& content_loader = GetNANDLoader(filename);
+  if (content_loader.IsValid() == false)
+    return 0;
+
+  u64 title_id = content_loader.GetTitleID();
+
+  // copy WAD's TMD header and contents to content directory
+
+  std::string content_path(Common::GetTitleContentPath(title_id, Common::FROM_CONFIGURED_ROOT));
+  std::string tmd_filename(Common::GetTMDFileName(title_id, Common::FROM_CONFIGURED_ROOT));
+  File::CreateFullPath(tmd_filename);
+
+  File::IOFile tmd_file(tmd_filename, "wb");
+  if (!tmd_file)
+  {
+    PanicAlertT("WAD installation failed: error creating %s", tmd_filename.c_str());
+    return 0;
+  }
+
+  tmd_file.WriteBytes(content_loader.GetTMDHeader(), CNANDContentLoader::TMD_HEADER_SIZE);
+
+  for (u32 i = 0; i < content_loader.GetContentSize(); i++)
+  {
+    const SNANDContent& content = content_loader.GetContent()[i];
+
+    tmd_file.WriteBytes(content.m_Header, CNANDContentLoader::CONTENT_HEADER_SIZE);
+
+    std::string app_filename;
+    if (content.m_Type & 0x8000)  // shared
+      app_filename = CSharedContent::AccessInstance().AddSharedContent(content.m_SHA1Hash);
+    else
+      app_filename = StringFromFormat("%s%08x.app", content_path.c_str(), content.m_ContentID);
+
+    if (!File::Exists(app_filename))
+    {
+      File::CreateFullPath(app_filename);
+      File::IOFile app_file(app_filename, "wb");
+      if (!app_file)
+      {
+        PanicAlertT("WAD installation failed: error creating %s", app_filename.c_str());
+        return 0;
+      }
+
+      app_file.WriteBytes(content.m_Data->Get().data(), content.m_Size);
+    }
+    else
+    {
+      INFO_LOG(DISCIO, "Content %s already exists.", app_filename.c_str());
+    }
+  }
+
+  // Extract and copy WAD's ticket to ticket directory
+  if (!AddTicket(title_id, content_loader.GetTicket()))
+  {
+    PanicAlertT("WAD installation failed: error creating ticket");
+    return 0;
+  }
+
+  cUIDsys::AccessInstance().AddTitle(title_id);
+
+  ClearCache();
+
+  return title_id;
 }
 
 bool AddTicket(u64 title_id, const std::vector<u8>& ticket)
 {
-	std::string ticket_filename = Common::GetTicketFileName(title_id, Common::FROM_CONFIGURED_ROOT);
-	File::CreateFullPath(ticket_filename);
+  std::string ticket_filename = Common::GetTicketFileName(title_id, Common::FROM_CONFIGURED_ROOT);
+  File::CreateFullPath(ticket_filename);
 
-	File::IOFile ticket_file(ticket_filename, "wb");
-	if (!ticket_file)
-		return false;
+  File::IOFile ticket_file(ticket_filename, "wb");
+  if (!ticket_file)
+    return false;
 
-	return ticket_file.WriteBytes(ticket.data(), ticket.size());
+  return ticket_file.WriteBytes(ticket.data(), ticket.size());
 }
 
-} // namespace end
-
+}  // namespace end