Fixed links.

lib/libcompress/source/lz4_wrapper.cpp

@@ -1,5 +1,5 @@
 #include <compress/lz4.h>
-#include "lz4/lz4.h"
+#include <lz4.h>
 
 void compress::lz4::compressData(const uint8_t* src, uint32_t src_len, uint8_t* dst, uint32_t dst_capacity, uint32_t& compressed_size)
 {

lib/libes/include/nn/es/SectionHeader_V2.h

@@ -1,8 +1,10 @@
 #pragma once
 #include <string>
 #include <fnd/ISerialisable.h>
-#include <es/ticket.h>
+#include <nn/es/ticket.h>
 
+namespace nn
+{
 namespace es
 {
 	class SectionHeader_V2 :
@@ -52,5 +54,5 @@ namespace es
 		uint16_t mRecordNum;
 		ticket::SectionType mSectionType;
 	};
-
 }
+}

lib/libes/include/nn/es/TicketBody_V2.h

@@ -2,8 +2,10 @@
 #include <string>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
-#include <es/ticket.h>
+#include <nn/es/ticket.h>
 
+namespace nn
+{
 namespace es
 {
 	class TicketBody_V2 :
@@ -98,5 +100,4 @@ namespace es
 		uint16_t mSectEntrySize;
 	};
 }
-
+}
-

lib/libes/include/nn/es/ticket.h

@@ -3,6 +3,8 @@
 #include <fnd/types.h>
 #include <crypto/rsa.h>
 
+namespace nn
+{
 namespace es
 {
 	namespace ticket
@@ -105,4 +107,5 @@ namespace es
 		inline uint16_t get_group(uint16_t index) const { return index & kGroupMask; }
 	};
 #pragma pack(pop)
+}
 }

lib/libes/source/SectionHeader_V2.cpp

@@ -1,16 +1,14 @@
-#include <es/SectionHeader_V2.h>
+#include <nn/es/SectionHeader_V2.h>
 
-
+nn::es::SectionHeader_V2::SectionHeader_V2()
-
-es::SectionHeader_V2::SectionHeader_V2()
 {}
 
-es::SectionHeader_V2::SectionHeader_V2(const SectionHeader_V2 & other)
+nn::es::SectionHeader_V2::SectionHeader_V2(const SectionHeader_V2 & other)
 {
 	*this = other;
 }
 
-void es::SectionHeader_V2::operator=(const SectionHeader_V2 & other)
+void nn::es::SectionHeader_V2::operator=(const SectionHeader_V2 & other)
 {
 	if (other.getBytes().size())
 	{
@@ -27,7 +25,7 @@ void es::SectionHeader_V2::operator=(const SectionHeader_V2 & other)
 	}
 }
 
-bool es::SectionHeader_V2::operator==(const SectionHeader_V2 & other) const
+bool nn::es::SectionHeader_V2::operator==(const SectionHeader_V2 & other) const
 {
 	return (mSectionOffset == other.mSectionOffset) \
 		&& (mRecordSize == other.mRecordSize) \
@@ -36,12 +34,12 @@ bool es::SectionHeader_V2::operator==(const SectionHeader_V2 & other) const
 		&& (mSectionType == other.mSectionType);
 }
 
-bool es::SectionHeader_V2::operator!=(const SectionHeader_V2 & other) const
+bool nn::es::SectionHeader_V2::operator!=(const SectionHeader_V2 & other) const
 {
 	return !(*this ==other);
 }
 
-void es::SectionHeader_V2::toBytes()
+void nn::es::SectionHeader_V2::toBytes()
 {
 	mRawBinary.alloc(sizeof(sSectionHeader_v2));
 	sSectionHeader_v2* hdr = (sSectionHeader_v2*)mRawBinary.data();
@@ -53,7 +51,7 @@ void es::SectionHeader_V2::toBytes()
 	hdr->section_type = (mSectionType);
 }
 
-void es::SectionHeader_V2::fromBytes(const byte_t * bytes, size_t len)
+void nn::es::SectionHeader_V2::fromBytes(const byte_t * bytes, size_t len)
 {
 	if (len < sizeof(sSectionHeader_v2))
 	{
@@ -73,12 +71,12 @@ void es::SectionHeader_V2::fromBytes(const byte_t * bytes, size_t len)
 	mSectionType = (ticket::SectionType)hdr->section_type.get();
 }
 
-const fnd::Vec<byte_t>& es::SectionHeader_V2::getBytes() const
+const fnd::Vec<byte_t>& nn::es::SectionHeader_V2::getBytes() const
 {
 	return mRawBinary;
 }
 
-void es::SectionHeader_V2::clear()
+void nn::es::SectionHeader_V2::clear()
 {
 	mRawBinary.clear();
 	mSectionOffset = 0;
@@ -88,52 +86,52 @@ void es::SectionHeader_V2::clear()
 	mSectionType = ticket::SECTION_PERMANENT;
 }
 
-uint32_t es::SectionHeader_V2::getSectionOffset() const
+uint32_t nn::es::SectionHeader_V2::getSectionOffset() const
 {
 	return mSectionOffset;
 }
 
-void es::SectionHeader_V2::setSectionOffset(uint32_t offset)
+void nn::es::SectionHeader_V2::setSectionOffset(uint32_t offset)
 {
 	mSectionOffset = offset;
 }
 
-uint32_t es::SectionHeader_V2::getRecordSize() const
+uint32_t nn::es::SectionHeader_V2::getRecordSize() const
 {
 	return mRecordSize;
 }
 
-void es::SectionHeader_V2::setRecordSize(uint32_t size)
+void nn::es::SectionHeader_V2::setRecordSize(uint32_t size)
 {
 	mRecordSize = size;
 }
 
-uint32_t es::SectionHeader_V2::getSectionSize() const
+uint32_t nn::es::SectionHeader_V2::getSectionSize() const
 {
 	return mSectionSize;
 }
 
-void es::SectionHeader_V2::getSectionSize(uint32_t size)
+void nn::es::SectionHeader_V2::getSectionSize(uint32_t size)
 {
 	mSectionSize = size;
 }
 
-uint16_t es::SectionHeader_V2::getRecordNum() const
+uint16_t nn::es::SectionHeader_V2::getRecordNum() const
 {
 	return mRecordNum;
 }
 
-void es::SectionHeader_V2::setRecordNum(uint16_t record_num)
+void nn::es::SectionHeader_V2::setRecordNum(uint16_t record_num)
 {
 	mRecordNum = record_num;
 }
 
-es::ticket::SectionType es::SectionHeader_V2::getSectionType() const
+nn::es::ticket::SectionType nn::es::SectionHeader_V2::getSectionType() const
 {
 	return mSectionType;
 }
 
-void es::SectionHeader_V2::setSectionType(ticket::SectionType type)
+void nn::es::SectionHeader_V2::setSectionType(ticket::SectionType type)
 {
 	mSectionType = type;
 }

lib/libes/source/TicketBody_V2.cpp

@@ -1,18 +1,16 @@
-#include <es/TicketBody_V2.h>
+#include <nn/es/TicketBody_V2.h>
 
-
+nn::es::TicketBody_V2::TicketBody_V2()
-
-es::TicketBody_V2::TicketBody_V2()
 {
 	clear();
 }
 
-es::TicketBody_V2::TicketBody_V2(const TicketBody_V2 & other)
+nn::es::TicketBody_V2::TicketBody_V2(const TicketBody_V2 & other)
 {
 	*this = other;
 }
 
-void es::TicketBody_V2::operator=(const TicketBody_V2 & other)
+void nn::es::TicketBody_V2::operator=(const TicketBody_V2 & other)
 {
 	if (other.getBytes().size())
 	{
@@ -40,7 +38,7 @@ void es::TicketBody_V2::operator=(const TicketBody_V2 & other)
 	}
 }
 
-bool es::TicketBody_V2::operator==(const TicketBody_V2 & other) const
+bool nn::es::TicketBody_V2::operator==(const TicketBody_V2 & other) const
 {
 	return (mIssuer == other.mIssuer) \
 		&& (memcmp(mEncTitleKey, other.mEncTitleKey, ticket::kEncTitleKeySize) == 0) \
@@ -59,12 +57,12 @@ bool es::TicketBody_V2::operator==(const TicketBody_V2 & other) const
 		&& (mSectEntrySize == other.mSectEntrySize);
 }
 
-bool es::TicketBody_V2::operator!=(const TicketBody_V2 & other) const
+bool nn::es::TicketBody_V2::operator!=(const TicketBody_V2 & other) const
 {
 	return !(*this == other);
 }
 
-void es::TicketBody_V2::toBytes()
+void nn::es::TicketBody_V2::toBytes()
 {
 	mRawBinary.alloc(sizeof(sTicketBody_v2));
 	sTicketBody_v2* body = (sTicketBody_v2*)mRawBinary.data();
@@ -94,7 +92,7 @@ void es::TicketBody_V2::toBytes()
 	body->sect_entry_size = (mSectEntrySize);
 }
 
-void es::TicketBody_V2::fromBytes(const byte_t * bytes, size_t len)
+void nn::es::TicketBody_V2::fromBytes(const byte_t * bytes, size_t len)
 {
 	if (len < sizeof(sTicketBody_v2))
 	{
@@ -134,12 +132,12 @@ void es::TicketBody_V2::fromBytes(const byte_t * bytes, size_t len)
 	mSectEntrySize = body->sect_entry_size.get();
 }
 
-const fnd::Vec<byte_t>& es::TicketBody_V2::getBytes() const
+const fnd::Vec<byte_t>& nn::es::TicketBody_V2::getBytes() const
 {
 	return mRawBinary;
 }
 
-void es::TicketBody_V2::clear()
+void nn::es::TicketBody_V2::clear()
 {
 	mRawBinary.clear();
 	mIssuer.clear();
@@ -160,12 +158,12 @@ void es::TicketBody_V2::clear()
 	mSectEntrySize = 0;
 }
 
-const std::string & es::TicketBody_V2::getIssuer() const
+const std::string & nn::es::TicketBody_V2::getIssuer() const
 {
 	return mIssuer;
 }
 
-void es::TicketBody_V2::setIssuer(const std::string & issuer)
+void nn::es::TicketBody_V2::setIssuer(const std::string & issuer)
 {
 	if (issuer.length() > ticket::kIssuerSize)
 	{
@@ -175,154 +173,154 @@ void es::TicketBody_V2::setIssuer(const std::string & issuer)
 	mIssuer = issuer;
 }
 
-const byte_t * es::TicketBody_V2::getEncTitleKey() const
+const byte_t * nn::es::TicketBody_V2::getEncTitleKey() const
 {
 	return mEncTitleKey;
 }
 
-void es::TicketBody_V2::setEncTitleKey(const byte_t * data, size_t len)
+void nn::es::TicketBody_V2::setEncTitleKey(const byte_t * data, size_t len)
 {
 	memset(mEncTitleKey, 0, ticket::kEncTitleKeySize);
 	memcpy(mEncTitleKey, data, _MIN(len, ticket::kEncTitleKeySize));
 }
 
-es::ticket::TitleKeyEncType es::TicketBody_V2::getTitleKeyEncType() const
+nn::es::ticket::TitleKeyEncType nn::es::TicketBody_V2::getTitleKeyEncType() const
 {
 	return mEncType;
 }
 
-void es::TicketBody_V2::setTitleKeyEncType(ticket::TitleKeyEncType type)
+void nn::es::TicketBody_V2::setTitleKeyEncType(ticket::TitleKeyEncType type)
 {
 	mEncType = type;
 }
 
-uint16_t es::TicketBody_V2::getTicketVersion() const
+uint16_t nn::es::TicketBody_V2::getTicketVersion() const
 {
 	return mTicketVersion;
 }
 
-void es::TicketBody_V2::setTicketVersion(uint16_t version)
+void nn::es::TicketBody_V2::setTicketVersion(uint16_t version)
 {
 	mTicketVersion = version;
 }
 
-es::ticket::LicenseType es::TicketBody_V2::getLicenseType() const
+nn::es::ticket::LicenseType nn::es::TicketBody_V2::getLicenseType() const
 {
 	return mLicenseType;
 }
 
-void es::TicketBody_V2::setLicenseType(ticket::LicenseType type)
+void nn::es::TicketBody_V2::setLicenseType(ticket::LicenseType type)
 {
 	mLicenseType = type;
 }
 
-byte_t es::TicketBody_V2::getCommonKeyId() const
+byte_t nn::es::TicketBody_V2::getCommonKeyId() const
 {
 	return mCommonKeyId;
 }
 
-void es::TicketBody_V2::setCommonKeyId(byte_t id)
+void nn::es::TicketBody_V2::setCommonKeyId(byte_t id)
 {
 	mCommonKeyId = id;
 }
 
-const fnd::List<es::ticket::PropertyMaskFlags>& es::TicketBody_V2::getPropertyFlags() const
+const fnd::List<nn::es::ticket::PropertyMaskFlags>& nn::es::TicketBody_V2::getPropertyFlags() const
 {
 	return mPropertyFlags;
 }
 
-void es::TicketBody_V2::setPropertyFlags(const fnd::List<es::ticket::PropertyMaskFlags>& flags)
+void nn::es::TicketBody_V2::setPropertyFlags(const fnd::List<nn::es::ticket::PropertyMaskFlags>& flags)
 {
 	mPropertyFlags = flags;
 }
 
-const byte_t * es::TicketBody_V2::getReservedRegion() const
+const byte_t * nn::es::TicketBody_V2::getReservedRegion() const
 {
 	return mReservedRegion;
 }
 
-void es::TicketBody_V2::setReservedRegion(const byte_t * data, size_t len)
+void nn::es::TicketBody_V2::setReservedRegion(const byte_t * data, size_t len)
 {
 	memset(mReservedRegion, 0, ticket::kReservedRegionSize);
 	memcpy(mReservedRegion, data, _MIN(len, ticket::kReservedRegionSize));
 }
 
-uint64_t es::TicketBody_V2::getTicketId() const
+uint64_t nn::es::TicketBody_V2::getTicketId() const
 {
 	return mTicketId;
 }
 
-void es::TicketBody_V2::setTicketId(uint64_t id)
+void nn::es::TicketBody_V2::setTicketId(uint64_t id)
 {
 	mTicketId = id;
 }
 
-uint64_t es::TicketBody_V2::getDeviceId() const
+uint64_t nn::es::TicketBody_V2::getDeviceId() const
 {
 	return mDeviceId;
 }
 
-void es::TicketBody_V2::setDeviceId(uint64_t id)
+void nn::es::TicketBody_V2::setDeviceId(uint64_t id)
 {
 	mDeviceId = id;
 }
 
-const byte_t * es::TicketBody_V2::getRightsId() const
+const byte_t * nn::es::TicketBody_V2::getRightsId() const
 {
 	return mRightsId;
 }
 
-void es::TicketBody_V2::setRightsId(const byte_t * id)
+void nn::es::TicketBody_V2::setRightsId(const byte_t * id)
 {
 	memcpy(mRightsId, id, ticket::kRightsIdSize);
 }
 
-uint32_t es::TicketBody_V2::getAccountId() const
+uint32_t nn::es::TicketBody_V2::getAccountId() const
 {
 	return mAccountId;
 }
 
-void es::TicketBody_V2::setAccountId(uint32_t id)
+void nn::es::TicketBody_V2::setAccountId(uint32_t id)
 {
 	mAccountId = id;
 }
 
-uint32_t es::TicketBody_V2::getSectionTotalSize() const
+uint32_t nn::es::TicketBody_V2::getSectionTotalSize() const
 {
 	return mSectTotalSize;
 }
 
-void es::TicketBody_V2::setSectionTotalSize(uint32_t size)
+void nn::es::TicketBody_V2::setSectionTotalSize(uint32_t size)
 {
 	mSectTotalSize = size;
 }
 
-uint32_t es::TicketBody_V2::getSectionHeaderOffset() const
+uint32_t nn::es::TicketBody_V2::getSectionHeaderOffset() const
 {
 	return mSectHeaderOffset;
 }
 
-void es::TicketBody_V2::setSectionHeaderOffset(uint32_t offset)
+void nn::es::TicketBody_V2::setSectionHeaderOffset(uint32_t offset)
 {
 	mSectHeaderOffset = offset;
 }
 
-uint16_t es::TicketBody_V2::getSectionNum() const
+uint16_t nn::es::TicketBody_V2::getSectionNum() const
 {
 	return mSectNum;
 }
 
-void es::TicketBody_V2::setSectionNum(uint16_t num)
+void nn::es::TicketBody_V2::setSectionNum(uint16_t num)
 {
 	mSectNum = num;
 }
 
-uint16_t es::TicketBody_V2::getSectionEntrySize() const
+uint16_t nn::es::TicketBody_V2::getSectionEntrySize() const
 {
 	return mSectEntrySize;
 }
 
-void es::TicketBody_V2::setSectionEntrySize(uint16_t size)
+void nn::es::TicketBody_V2::setSectionEntrySize(uint16_t size)
 {
 	mSectEntrySize = size;
 }

lib/libhac-hb/include/nn/hac/AssetHeader.h

@@ -1,9 +1,11 @@
 #pragma once
-#include <nx/aset.h>
+#include <nn/hac/aset.h>
 #include <fnd/List.h>
 #include <fnd/ISerialisable.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class AssetHeader : 
 		public fnd::ISerialisable
@@ -66,5 +68,5 @@ namespace nx
 		sSection mNacpInfo;
 		sSection mRomfsInfo;
 	};
-
+}
 }

lib/libhac-hb/include/nn/hac/aset.h

@@ -1,8 +1,10 @@
 #pragma once
-
 #include <fnd/types.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
-namespace nx
+
+namespace nn
+{
+namespace hac
 {
 	namespace aset
 	{
@@ -27,4 +29,5 @@ namespace nx
 		sAssetSection romfs;
 	};
 #pragma pack(pop)
+}
 }

lib/libhac-hb/include/nn/hac/nro-hb.h

@@ -1,11 +1,14 @@
 #pragma once
+#include <nn/hac/nro.h>
+#include <nn/hac/macro.h>
 
-#include <nx/nro.h>
+namespace nn
-#include <nx/macro.h>
+{
-namespace nx
+namespace hac
 {
 	namespace nro
 	{
 		static const uint64_t kNroHomebrewStructMagic = _MAKE_STRUCT_MAGIC_U64("HOMEBREW");
 	}
+}
 }

lib/libhac-hb/makefile

@@ -3,7 +3,7 @@ SRC_DIR = source
 OBJS = $(foreach dir,$(SRC_DIR),$(subst .cpp,.o,$(wildcard $(dir)/*.cpp))) $(foreach dir,$(SRC_DIR),$(subst .c,.o,$(wildcard $(dir)/*.c)))
 
 # External dependencies
-DEPENDS = fnd crypto nx
+DEPENDS = fnd crypto hac
 LIB_DIR = ..
 INCS = -I"include" $(foreach dep,$(DEPENDS), -I"$(LIB_DIR)/lib$(dep)/include")
 

lib/libhac-hb/source/AssetHeader.cpp

@@ -1,16 +1,16 @@
-#include <nx/AssetHeader.h>
+#include <nn/hac/AssetHeader.h>
 
-nx::AssetHeader::AssetHeader()
+nn::hac::AssetHeader::AssetHeader()
 {
 	clear();
 }
 
-nx::AssetHeader::AssetHeader(const AssetHeader& other)
+nn::hac::AssetHeader::AssetHeader(const AssetHeader& other)
 {
 	*this = other;
 }
 
-void nx::AssetHeader::operator=(const AssetHeader& other)
+void nn::hac::AssetHeader::operator=(const AssetHeader& other)
 {
 	mRawBinary = other.mRawBinary;
 	mIconInfo = other.mIconInfo;
@@ -18,22 +18,22 @@ void nx::AssetHeader::operator=(const AssetHeader& other)
 	mRomfsInfo = other.mRomfsInfo;
 }
 
-bool nx::AssetHeader::operator==(const AssetHeader& other) const
+bool nn::hac::AssetHeader::operator==(const AssetHeader& other) const
 {
 	return (mIconInfo == other.mIconInfo) \
 		&& (mNacpInfo == other.mNacpInfo) \
 		&& (mRomfsInfo == other.mRomfsInfo);
 }
 
-bool nx::AssetHeader::operator!=(const AssetHeader& other) const
+bool nn::hac::AssetHeader::operator!=(const AssetHeader& other) const
 {
 	return !(*this == other);
 }
 
-void nx::AssetHeader::toBytes()
+void nn::hac::AssetHeader::toBytes()
 {
 	mRawBinary.alloc(sizeof(sAssetHeader));
-	nx::sAssetHeader* hdr = (nx::sAssetHeader*)mRawBinary.data();
+	nn::hac::sAssetHeader* hdr = (nn::hac::sAssetHeader*)mRawBinary.data();
 
 	// set header identifers
 	hdr->st_magic = aset::kAssetStructMagic;
@@ -52,7 +52,7 @@ void nx::AssetHeader::toBytes()
 	hdr->romfs.size = mRomfsInfo.size;
 }
 
-void nx::AssetHeader::fromBytes(const byte_t* bytes, size_t len)
+void nn::hac::AssetHeader::fromBytes(const byte_t* bytes, size_t len)
 {
 	// check input data size
 	if (len < sizeof(sAssetHeader))
@@ -68,7 +68,7 @@ void nx::AssetHeader::fromBytes(const byte_t* bytes, size_t len)
 	memcpy(mRawBinary.data(), bytes, mRawBinary.size());
 
 	// get sAssetHeader ptr
-	const nx::sAssetHeader* hdr = (const nx::sAssetHeader*)mRawBinary.data();
+	const nn::hac::sAssetHeader* hdr = (const nn::hac::sAssetHeader*)mRawBinary.data();
 	
 	// check NRO signature
 	if (hdr->st_magic.get() != aset::kAssetStructMagic)
@@ -90,12 +90,12 @@ void nx::AssetHeader::fromBytes(const byte_t* bytes, size_t len)
 	mRomfsInfo.size = hdr->romfs.size.get();
 }
 
-const fnd::Vec<byte_t>& nx::AssetHeader::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::AssetHeader::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::AssetHeader::clear()
+void nn::hac::AssetHeader::clear()
 {
 	mRawBinary.clear();
 	memset(&mIconInfo, 0, sizeof(mIconInfo));
@@ -103,32 +103,32 @@ void nx::AssetHeader::clear()
 	memset(&mRomfsInfo, 0, sizeof(mRomfsInfo));
 }
 
-const nx::AssetHeader::sSection& nx::AssetHeader::getIconInfo() const
+const nn::hac::AssetHeader::sSection& nn::hac::AssetHeader::getIconInfo() const
 {
 	return mIconInfo;
 }
 
-void nx::AssetHeader::setIconInfo(const nx::AssetHeader::sSection& info)
+void nn::hac::AssetHeader::setIconInfo(const nn::hac::AssetHeader::sSection& info)
 {
 	mIconInfo = info;
 }
 
-const nx::AssetHeader::sSection& nx::AssetHeader::getNacpInfo() const
+const nn::hac::AssetHeader::sSection& nn::hac::AssetHeader::getNacpInfo() const
 {
 	return mNacpInfo;
 }
 
-void nx::AssetHeader::setNacpInfo(const sSection& info)
+void nn::hac::AssetHeader::setNacpInfo(const sSection& info)
 {
 	mNacpInfo = info;
 }
 
-const nx::AssetHeader::sSection& nx::AssetHeader::getRomfsInfo() const
+const nn::hac::AssetHeader::sSection& nn::hac::AssetHeader::getRomfsInfo() const
 {
 	return mRomfsInfo;
 }
 
-void nx::AssetHeader::setRomfsInfo(const sSection& info)
+void nn::hac::AssetHeader::setRomfsInfo(const sSection& info)
 {
 	mRomfsInfo = info;
 }

lib/libhac/include/nn/hac/AccessControlInfoBinary.h

@@ -2,12 +2,14 @@
 #include <string>
 #include <fnd/types.h>
 #include <fnd/ISerialisable.h>
-#include <nx/aci.h>
+#include <nn/hac/aci.h>
-#include <nx/FileSystemAccessControlBinary.h>
+#include <nn/hac/FileSystemAccessControlBinary.h>
-#include <nx/ServiceAccessControlBinary.h>
+#include <nn/hac/ServiceAccessControlBinary.h>
-#include <nx/KernelCapabilityBinary.h>
+#include <nn/hac/KernelCapabilityBinary.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class AccessControlInfoBinary : public fnd::ISerialisable
 	{
@@ -30,13 +32,13 @@ namespace nx
 		uint64_t getProgramId() const;
 		void setProgramId(uint64_t program_id);
 
-		const nx::FileSystemAccessControlBinary& getFileSystemAccessControl() const;
+		const nn::hac::FileSystemAccessControlBinary& getFileSystemAccessControl() const;
 		void setFileSystemAccessControl(const FileSystemAccessControlBinary& fac);
 
-		const nx::ServiceAccessControlBinary& getServiceAccessControl() const;
+		const nn::hac::ServiceAccessControlBinary& getServiceAccessControl() const;
 		void setServiceAccessControl(const ServiceAccessControlBinary& sac);
 
-		const nx::KernelCapabilityBinary& getKernelCapabilities() const;
+		const nn::hac::KernelCapabilityBinary& getKernelCapabilities() const;
 		void setKernelCapabilities(const KernelCapabilityBinary& kc);
 	private:
 		const std::string kModuleName = "ACCESS_CONTROL_INFO_BINARY";
@@ -46,8 +48,9 @@ namespace nx
 
 		// variables
 		uint64_t mProgramId;
-		nx::FileSystemAccessControlBinary mFileSystemAccessControl;
+		nn::hac::FileSystemAccessControlBinary mFileSystemAccessControl;
-		nx::ServiceAccessControlBinary mServiceAccessControl;
+		nn::hac::ServiceAccessControlBinary mServiceAccessControl;
-		nx::KernelCapabilityBinary mKernelCapabilities;
+		nn::hac::KernelCapabilityBinary mKernelCapabilities;
 	};
+}
 }

lib/libhac/include/nn/hac/AccessControlInfoDescBinary.h

@@ -3,12 +3,14 @@
 #include <fnd/types.h>
 #include <fnd/List.h>
 #include <fnd/ISerialisable.h>
-#include <nx/aci.h>
+#include <nn/hac/aci.h>
-#include <nx/FileSystemAccessControlBinary.h>
+#include <nn/hac/FileSystemAccessControlBinary.h>
-#include <nx/ServiceAccessControlBinary.h>
+#include <nn/hac/ServiceAccessControlBinary.h>
-#include <nx/KernelCapabilityBinary.h>
+#include <nn/hac/KernelCapabilityBinary.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class AccessControlInfoDescBinary : public fnd::ISerialisable
 	{
@@ -63,13 +65,13 @@ namespace nx
 		const sProgramIdRestrict& getProgramIdRestrict() const;
 		void setProgramIdRestrict(const sProgramIdRestrict& pid_restrict);
 
-		const nx::FileSystemAccessControlBinary& getFileSystemAccessControl() const;
+		const nn::hac::FileSystemAccessControlBinary& getFileSystemAccessControl() const;
 		void setFileSystemAccessControl(const FileSystemAccessControlBinary& fac);
 
-		const nx::ServiceAccessControlBinary& getServiceAccessControl() const;
+		const nn::hac::ServiceAccessControlBinary& getServiceAccessControl() const;
 		void setServiceAccessControl(const ServiceAccessControlBinary& sac);
 
-		const nx::KernelCapabilityBinary& getKernelCapabilities() const;
+		const nn::hac::KernelCapabilityBinary& getKernelCapabilities() const;
 		void setKernelCapabilities(const KernelCapabilityBinary& kc);
 	private:
 		const std::string kModuleName = "ACCESS_CONTROL_INFO_DESC_BINARY";
@@ -81,8 +83,9 @@ namespace nx
 		crypto::rsa::sRsa2048Key mNcaHeaderSignature2Key;
 		fnd::List<aci::Flag> mFlags;
 		sProgramIdRestrict mProgramIdRestrict;
-		nx::FileSystemAccessControlBinary mFileSystemAccessControl;
+		nn::hac::FileSystemAccessControlBinary mFileSystemAccessControl;
-		nx::ServiceAccessControlBinary mServiceAccessControl;
+		nn::hac::ServiceAccessControlBinary mServiceAccessControl;
-		nx::KernelCapabilityBinary mKernelCapabilities;
+		nn::hac::KernelCapabilityBinary mKernelCapabilities;
 	};
+}
 }

lib/libhac/include/nn/hac/AesKeygen.h

@@ -3,7 +3,9 @@
 #include <fnd/types.h>
 #include <crypto/aes.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class AesKeygen
 	{
@@ -16,4 +18,5 @@ namespace nx
 		// 3 stage key generation dst = ((src1_key.decrypt(src1)).decrypt(src2)).decrypt(src3)
 		static void generateKey(byte_t* dst, const byte_t* src1, const byte_t* src2, const byte_t* src3, const byte_t* src1_key);
 	};
+}
 }

lib/libhac/include/nn/hac/ApplicationControlPropertyBinary.h

@@ -3,9 +3,11 @@
 #include <fnd/types.h>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
-#include <nx/nacp.h>
+#include <nn/hac/nacp.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class ApplicationControlPropertyBinary :
 		public fnd::ISerialisable
@@ -229,7 +231,7 @@ namespace nx
 		nacp::TouchScreenUsageMode mTouchScreenUsageMode;
 		nacp::AocRegistrationType mAocRegistrationType;
 		nacp::AttributeFlag mAttributeFlag;
-		fnd::List<nx::nacp::Language> mSupportedLanguages;
+		fnd::List<nn::hac::nacp::Language> mSupportedLanguages;
 		nacp::ParentalControlFlag mParentalControlFlag;
 		nacp::ScreenshotMode mScreenshotMode;
 		nacp::VideoCaptureMode mVideoCaptureMode;
@@ -263,4 +265,5 @@ namespace nx
 		nacp::RepairFlag mRepairFlag;
 		byte_t mProgramIndex;
 	};
+}
 }

lib/libhac/include/nn/hac/ApplicationControlPropertyUtils.h

@@ -1,7 +1,9 @@
 #pragma once
-#include <nx/nacp.h>
+#include <nn/hac/nacp.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class ApplicationControlPropertyUtils
 	{
@@ -9,4 +11,5 @@ namespace nx
 		static bool validateSaveDataSizeMax(int64_t size, int64_t alignment);
 		static bool validateSaveDataSize(int64_t size);
 	};
+}
 }

lib/libhac/include/nn/hac/ContentMetaBinary.h

@@ -2,10 +2,11 @@
 #include <string>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
-#include <nx/cnmt.h>
+#include <nn/hac/cnmt.h>
 
-
+namespace nn
-namespace nx
+{
+namespace hac
 {
 	class ContentMetaBinary :
 		public fnd::ISerialisable
@@ -200,17 +201,17 @@ namespace nx
 		const DeltaMetaExtendedHeader& getDeltaMetaExtendedHeader() const;
 		void setDeltaMetaExtendedHeader(const DeltaMetaExtendedHeader& exhdr);
 
-		const fnd::List<nx::ContentMetaBinary::ContentInfo>& getContentInfo() const;
+		const fnd::List<nn::hac::ContentMetaBinary::ContentInfo>& getContentInfo() const;
-		void setContentInfo(const fnd::List<nx::ContentMetaBinary::ContentInfo>& info);
+		void setContentInfo(const fnd::List<nn::hac::ContentMetaBinary::ContentInfo>& info);
 
-		const fnd::List<nx::ContentMetaBinary::ContentMetaInfo>& getContentMetaInfo() const;
+		const fnd::List<nn::hac::ContentMetaBinary::ContentMetaInfo>& getContentMetaInfo() const;
-		void setContentMetaInfo(const fnd::List<nx::ContentMetaBinary::ContentMetaInfo>& info);
+		void setContentMetaInfo(const fnd::List<nn::hac::ContentMetaBinary::ContentMetaInfo>& info);
 
 		const fnd::Vec<byte_t>& getExtendedData() const;
 		void setExtendedData(const fnd::Vec<byte_t>& data);
 
-		const nx::sDigest& getDigest() const;
+		const nn::hac::sDigest& getDigest() const;
-		void setDigest(const nx::sDigest& digest);
+		void setDigest(const nn::hac::sDigest& digest);
 
 
 	private:
@@ -232,10 +233,10 @@ namespace nx
 		AddOnContentMetaExtendedHeader mAddOnContentMetaExtendedHeader;
 		DeltaMetaExtendedHeader mDeltaMetaExtendedHeader;
 
-		fnd::List<nx::ContentMetaBinary::ContentInfo> mContentInfo;
+		fnd::List<nn::hac::ContentMetaBinary::ContentInfo> mContentInfo;
-		fnd::List<nx::ContentMetaBinary::ContentMetaInfo> mContentMetaInfo;
+		fnd::List<nn::hac::ContentMetaBinary::ContentMetaInfo> mContentMetaInfo;
 		fnd::Vec<byte_t> mExtendedData;
-		nx::sDigest mDigest;
+		nn::hac::sDigest mDigest;
 
 		inline size_t getExtendedHeaderOffset() const { return sizeof(sContentMetaHeader); }
 		inline size_t getContentInfoOffset(size_t exhdrSize) const { return getExtendedHeaderOffset() + exhdrSize; }
@@ -248,4 +249,5 @@ namespace nx
 		size_t getExtendedDataSize(cnmt::ContentMetaType type, const byte_t* data) const;
 		void validateBinary(const byte_t* bytes, size_t len) const;
 	};
+}
 }

lib/libhac/include/nn/hac/FileSystemAccessControlBinary.h

@@ -3,17 +3,18 @@
 #include <fnd/types.h>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
-#include <nx/fac.h>
+#include <nn/hac/fac.h>
 
-
+namespace nn
-namespace nx
+{
+namespace hac
 {
 	class FileSystemAccessControlBinary : public fnd::ISerialisable
 	{
 	public:
 		struct sSaveDataOwnerId
 		{
-			nx::fac::SaveDataOwnerIdAccessType access_type;
+			nn::hac::fac::SaveDataOwnerIdAccessType access_type;
 			uint64_t id;
 
 			void operator=(const sSaveDataOwnerId& other)
@@ -72,4 +73,5 @@ namespace nx
 		fnd::List<uint64_t> mContentOwnerIdList;
 		fnd::List<sSaveDataOwnerId> mSaveDataOwnerIdList;
 	};
+}
 }

lib/libhac/include/nn/hac/HandleTableSizeEntry.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <string>
 #include <fnd/types.h>
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class HandleTableSizeEntry
 	{
@@ -44,4 +46,5 @@ namespace nx
 			mHandleTableSize = field & kMaxHandleTableSize;
 		}
 	};
+}
 }

lib/libhac/include/nn/hac/HandleTableSizeHandler.h

@@ -1,8 +1,10 @@
 #pragma once
-#include <nx/IKernelCapabilityHandler.h>
+#include <nn/hac/IKernelCapabilityHandler.h>
-#include <nx/HandleTableSizeEntry.h>
+#include <nn/hac/HandleTableSizeEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class HandleTableSizeHandler :
 		public IKernelCapabilityHandler
@@ -32,4 +34,4 @@ namespace nx
 		HandleTableSizeEntry mEntry;
 	};
 }
-
+}

lib/libhac/include/nn/hac/HierarchicalIntegrityHeader.h

@@ -1,10 +1,12 @@
 #pragma once
-#include <nx/hierarchicalintegrity.h>
+#include <nn/hac/hierarchicalintegrity.h>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
 #include <crypto/sha.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class HierarchicalIntegrityHeader :
 		public fnd::ISerialisable
@@ -64,5 +66,5 @@ namespace nx
 		fnd::List<sLayer> mLayerInfo;
 		fnd::List<crypto::sha::sSha256Hash> mMasterHashList;
 	};
-
+}
 }

lib/libhac/include/nn/hac/HierarchicalSha256Header.h

@@ -1,9 +1,11 @@
 #pragma once
-#include <nx/hierarchicalsha256.h>
+#include <nn/hac/hierarchicalsha256.h>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class HierarchicalSha256Header :
 		public fnd::ISerialisable
@@ -65,5 +67,5 @@ namespace nx
 		size_t mHashBlockSize;
 		fnd::List<sLayer> mLayerInfo;
 	};
-
+}
 }

lib/libhac/include/nn/hac/IKernelCapabilityHandler.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <fnd/types.h>
 #include <fnd/List.h>
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class IKernelCapabilityHandler
 	{
@@ -14,4 +16,4 @@ namespace nx
 		virtual bool isSet() const = 0;
 	};
 }
-
+}

lib/libhac/include/nn/hac/InteruptEntry.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <string>
 #include <fnd/types.h>
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class InteruptEntry
 	{
@@ -52,5 +54,5 @@ namespace nx
 			mInterupt[1] = (field >> kInteruptBits) & kInteruptMax;
 		}
 	};
-
+}
 }

lib/libhac/include/nn/hac/InteruptHandler.h

@@ -1,8 +1,10 @@
 #pragma once
-#include <nx/IKernelCapabilityHandler.h>
+#include <nn/hac/IKernelCapabilityHandler.h>
-#include <nx/InteruptEntry.h>
+#include <nn/hac/InteruptEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class InteruptHandler :
 		public IKernelCapabilityHandler
@@ -31,4 +33,4 @@ namespace nx
 		fnd::List<uint16_t> mInterupts;
 	};
 }
-
+}

lib/libhac/include/nn/hac/KernelCapabilityBinary.h

@@ -3,16 +3,18 @@
 #include <vector>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
-#include <nx/ThreadInfoHandler.h>
+#include <nn/hac/ThreadInfoHandler.h>
-#include <nx/SystemCallHandler.h>
+#include <nn/hac/SystemCallHandler.h>
-#include <nx/MemoryMappingHandler.h>
+#include <nn/hac/MemoryMappingHandler.h>
-#include <nx/InteruptHandler.h>
+#include <nn/hac/InteruptHandler.h>
-#include <nx/MiscParamsHandler.h>
+#include <nn/hac/MiscParamsHandler.h>
-#include <nx/KernelVersionHandler.h>
+#include <nn/hac/KernelVersionHandler.h>
-#include <nx/HandleTableSizeHandler.h>
+#include <nn/hac/HandleTableSizeHandler.h>
-#include <nx/MiscFlagsHandler.h>
+#include <nn/hac/MiscFlagsHandler.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class KernelCapabilityBinary :
 		public fnd::ISerialisable
@@ -73,4 +75,4 @@ namespace nx
 		MiscFlagsHandler mMiscFlags;
 	};
 }
-
+}

lib/libhac/include/nn/hac/KernelCapabilityEntry.h

@@ -1,8 +1,10 @@
 #pragma once
 #include <fnd/types.h>
-#include <nx/kc.h>
+#include <nn/hac/kc.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class KernelCapabilityEntry
 	{
@@ -47,4 +49,4 @@ namespace nx
 		}
 	};
 }
-
+}

lib/libhac/include/nn/hac/KernelVersionEntry.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <string>
 #include <fnd/types.h>
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class KernelVersionEntry
 	{
@@ -53,4 +55,4 @@ namespace nx
 		}
 	};
 }
-
+}

lib/libhac/include/nn/hac/KernelVersionHandler.h

@@ -1,8 +1,10 @@
 #pragma once
-#include <nx/IKernelCapabilityHandler.h>
+#include <nn/hac/IKernelCapabilityHandler.h>
-#include <nx/KernelVersionEntry.h>
+#include <nn/hac/KernelVersionEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class KernelVersionHandler :
 		public IKernelCapabilityHandler
@@ -34,4 +36,4 @@ namespace nx
 		KernelVersionEntry mEntry;
 	};
 }
-
+}

lib/libhac/include/nn/hac/MemoryMappingHandler.h

@@ -1,7 +1,9 @@
 #pragma once
-#include <nx/IKernelCapabilityHandler.h>
+#include <nn/hac/IKernelCapabilityHandler.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class MemoryMappingHandler :
 		public IKernelCapabilityHandler
@@ -75,4 +77,4 @@ namespace nx
 		fnd::List<sMemoryMapping> mMemPage;
 	};
 }
-
+}

lib/libhac/include/nn/hac/MemoryPageEntry.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <string>
 #include <fnd/types.h>
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class MemoryPageEntry
 	{
@@ -56,5 +58,5 @@ namespace nx
 			mUseFlag = mCap.getType() == kc::KC_MEMORY_MAP;
 		}
 	};
-
 }
+}

lib/libhac/include/nn/hac/MiscFlagsEntry.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <string>
 #include <fnd/types.h>
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class MiscFlagsEntry
 	{
@@ -44,5 +46,5 @@ namespace nx
 			mFlags = field & kMaxVal;
 		}
 	};
-
 }
+}

lib/libhac/include/nn/hac/MiscFlagsHandler.h

@@ -1,8 +1,10 @@
 #pragma once
-#include <nx/IKernelCapabilityHandler.h>
+#include <nn/hac/IKernelCapabilityHandler.h>
-#include <nx/MiscFlagsEntry.h>
+#include <nn/hac/MiscFlagsEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class MiscFlagsHandler :
 		public IKernelCapabilityHandler
@@ -51,5 +53,5 @@ namespace nx
 		bool mIsSet;
 		fnd::List<Flags> mFlags;
 	};
-
 }
+}

lib/libhac/include/nn/hac/MiscParamsEntry.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <string>
 #include <fnd/types.h>
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class MiscParamsEntry
 	{
@@ -44,6 +46,5 @@ namespace nx
 			mProgramType = field & kMaxProgramType;
 		}
 	};
-
+}
-
 }

lib/libhac/include/nn/hac/MiscParamsHandler.h

@@ -1,8 +1,10 @@
 #pragma once
-#include <nx/IKernelCapabilityHandler.h>
+#include <nn/hac/IKernelCapabilityHandler.h>
-#include <nx/MiscParamsEntry.h>
+#include <nn/hac/MiscParamsEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class MiscParamsHandler :
 		public IKernelCapabilityHandler
@@ -32,4 +34,4 @@ namespace nx
 		MiscParamsEntry mEntry;
 	};
 }
-
+}

lib/libhac/include/nn/hac/NcaHeader.h

@@ -1,9 +1,11 @@
 #pragma once
-#include <nx/nca.h>
+#include <nn/hac/nca.h>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class NcaHeader : 
 		public fnd::ISerialisable
@@ -112,5 +114,5 @@ namespace nx
 		uint64_t blockNumToSize(uint32_t block_num) const;
 		uint32_t sizeToBlockNum(uint64_t real_size) const;
 	};
-
+}
 }

lib/libhac/include/nn/hac/NcaUtils.h

@@ -1,14 +1,17 @@
 #pragma once
-#include <nx/nca.h>
+#include <nn/hac/nca.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class NcaUtils
 	{
 	public:
-		static inline size_t sectorToOffset(size_t sector_index) { return sector_index * nx::nca::kSectorSize; }
+		static inline size_t sectorToOffset(size_t sector_index) { return sector_index * nn::hac::nca::kSectorSize; }
 		static void decryptNcaHeader(const byte_t* src, byte_t* dst, const crypto::aes::sAesXts128Key& key);
 		static byte_t getMasterKeyRevisionFromKeyGeneration(byte_t key_generation);
-		static void getNcaPartitionAesCtr(const nx::sNcaFsHeader* hdr, byte_t* ctr);
+		static void getNcaPartitionAesCtr(const nn::hac::sNcaFsHeader* hdr, byte_t* ctr);
 	};
+}
 }

lib/libhac/include/nn/hac/NpdmBinary.h

@@ -2,12 +2,13 @@
 #include <string>
 #include <fnd/List.h>
 #include <fnd/ISerialisable.h>
-#include <nx/npdm.h>
+#include <nn/hac/npdm.h>
-#include <nx/AccessControlInfoBinary.h>
+#include <nn/hac/AccessControlInfoBinary.h>
-#include <nx/AccessControlInfoDescBinary.h>
+#include <nn/hac/AccessControlInfoDescBinary.h>
 
-
+namespace nn
-namespace nx
+{
+namespace hac
 {
 	class NpdmBinary :
 		public fnd::ISerialisable
@@ -75,5 +76,5 @@ namespace nx
 		AccessControlInfoBinary mAci;
 		AccessControlInfoDescBinary mAcid;
 	};
-
 }
+}

lib/libhac/include/nn/hac/NroHeader.h

@@ -1,9 +1,11 @@
 #pragma once
-#include <nx/nro.h>
+#include <nn/hac/nro.h>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class NroHeader : 
 		public fnd::ISerialisable
@@ -134,5 +136,5 @@ namespace nx
 		sSection mRoDynStrInfo;
 		sSection mRoDynSymInfo;
 	};
-
+}
 }

lib/libhac/include/nn/hac/NsoHeader.h

@@ -1,9 +1,11 @@
 #pragma once
-#include <nx/nso.h>
+#include <nn/hac/nso.h>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class NsoHeader : 
 		public fnd::ISerialisable
@@ -142,5 +144,5 @@ namespace nx
 		sLayout mRoDynStrInfo;
 		sLayout mRoDynSymInfo;
 	};
-
+}
 }

lib/libhac/include/nn/hac/PfsHeader.h

@@ -3,10 +3,11 @@
 #include <fnd/types.h>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
-#include <nx/pfs.h>
+#include <nn/hac/pfs.h>
 
-
+namespace nn
-namespace nx
+{
+namespace hac
 {
 	class PfsHeader :
 		public fnd::ISerialisable
@@ -99,4 +100,4 @@ namespace nx
 		void calculateOffsets(size_t data_offset);
 	};
 }
-
+}

lib/libhac/include/nn/hac/ServiceAccessControlBinary.h

@@ -3,9 +3,11 @@
 #include <vector>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
-#include <nx/ServiceAccessControlEntry.h>
+#include <nn/hac/ServiceAccessControlEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class ServiceAccessControlBinary :
 		public fnd::ISerialisable
@@ -36,5 +38,5 @@ namespace nx
 		// variables
 		fnd::List<ServiceAccessControlEntry> mServices;
 	};
-
+}
 }

lib/libhac/include/nn/hac/ServiceAccessControlEntry.h

@@ -3,7 +3,9 @@
 #include <fnd/types.h>
 #include <fnd/ISerialisable.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class ServiceAccessControlEntry : 
 		public fnd::ISerialisable
@@ -48,4 +50,5 @@ namespace nx
 		bool isEqual(const ServiceAccessControlEntry& other) const;
 		void copyFrom(const ServiceAccessControlEntry& other);
 	};
+}
 }

lib/libhac/include/nn/hac/SystemCallEntry.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <string>
 #include <fnd/types.h>
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class SystemCallEntry
 	{
@@ -54,4 +56,4 @@ namespace nx
 		}
 	};
 }
-
+}

lib/libhac/include/nn/hac/SystemCallHandler.h

@@ -1,7 +1,9 @@
 #pragma once
-#include <nx/IKernelCapabilityHandler.h>
+#include <nn/hac/IKernelCapabilityHandler.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class SystemCallHandler :
 		public IKernelCapabilityHandler
@@ -32,5 +34,5 @@ namespace nx
 		bool mIsSet;
 		fnd::List<uint8_t> mSystemCalls;
 	};
-
+}
 }

lib/libhac/include/nn/hac/ThreadInfoEntry.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <string>
 #include <fnd/types.h>
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class ThreadInfoEntry
 	{
@@ -64,3 +66,4 @@ namespace nx
 		}
 	};
 }
+}

lib/libhac/include/nn/hac/ThreadInfoHandler.h

@@ -1,8 +1,10 @@
 #pragma once
-#include <nx/IKernelCapabilityHandler.h>
+#include <nn/hac/IKernelCapabilityHandler.h>
-#include <nx/ThreadInfoEntry.h>
+#include <nn/hac/ThreadInfoEntry.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class ThreadInfoHandler :
 		public IKernelCapabilityHandler
@@ -38,4 +40,4 @@ namespace nx
 		ThreadInfoEntry mEntry;
 	};
 }
-
+}

lib/libhac/include/nn/hac/XciHeader.h

@@ -1,9 +1,11 @@
 #pragma once
-#include <nx/xci.h>
+#include <nn/hac/xci.h>
 #include <fnd/ISerialisable.h>
 #include <fnd/List.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class XciHeader : 
 		public fnd::ISerialisable
@@ -121,5 +123,5 @@ namespace nx
 		byte_t mUppHash[8];
 		uint64_t mUppId;
 	};
-
+}
 }

lib/libhac/include/nn/hac/XciUtils.h

@@ -1,13 +1,16 @@
 #pragma once
-#include <nx/xci.h>
+#include <nn/hac/xci.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	class XciUtils
 	{
 	public:
 		static inline uint64_t blockToAddr(uint32_t block) { return ((uint64_t)block) << 9; }
-		static void getXciHeaderAesIv(const nx::sXciHeader* hdr, byte_t* iv);
+		static void getXciHeaderAesIv(const nn::hac::sXciHeader* hdr, byte_t* iv);
 		static void decryptXciHeader(const byte_t* src, byte_t* dst, const byte_t* key);
 	};
+}
 }

lib/libhac/include/nn/hac/aci.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <fnd/types.h>
 #include <crypto/rsa.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace aci
 	{
@@ -50,4 +52,5 @@ namespace nx
 		sAciSection kc;
 	};
 #pragma pack(pop)
+}
 }

lib/libhac/include/nn/hac/cnmt.h

@@ -2,7 +2,9 @@
 #include <fnd/types.h>
 #include <crypto/sha.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace cnmt
 	{
@@ -132,4 +134,5 @@ namespace nx
 		byte_t data[cnmt::kDigestLen];
 	};
 #pragma pack(pop)
+}
 }

lib/libhac/include/nn/hac/elf.h

@@ -1,7 +1,9 @@
 #pragma once
 #include <fnd/types.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace elf
 	{
@@ -64,4 +66,5 @@ namespace nx
 		le_uint64_t size;
 	};
 #pragma pack(pop)
+}
 }

lib/libhac/include/nn/hac/fac.h

@@ -1,7 +1,9 @@
 #pragma once
 #include <fnd/types.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace fac
 	{
@@ -54,4 +56,5 @@ namespace nx
 		} content_owner_ids, save_data_owner_ids; // the data for these follow later in binary. start/end relative to base of FacData instance
 	};
 #pragma pack(pop)
+}
 }

lib/libhac/include/nn/hac/hierarchicalintegrity.h

@@ -1,8 +1,10 @@
 #pragma once
 #include <fnd/types.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace hierarchicalintegrity
 	{
@@ -30,3 +32,4 @@ namespace nx
 	};
 #pragma pack(pop)
 }
+}

lib/libhac/include/nn/hac/hierarchicalsha256.h

@@ -2,7 +2,9 @@
 #include <fnd/types.h>
 #include <crypto/sha.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace hierarchicalsha256
 	{
@@ -24,3 +26,4 @@ namespace nx
 	};
 #pragma pack(pop)
 }
+}

lib/libhac/include/nn/hac/kc.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <fnd/types.h>
 #include <crypto/rsa.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace kc
 	{
@@ -21,4 +23,5 @@ namespace nx
 			KC_MISC_FLAGS = 16
 		};
 	}
+}
 }

lib/libhac/include/nn/hac/nacp.h

@@ -1,7 +1,9 @@
 #pragma once
 #include <fnd/types.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace nacp
 	{
@@ -217,4 +219,5 @@ namespace nx
 		byte_t reserved_04[0xDED];
 	};
 #pragma pack(pop)
+}
 }

lib/libhac/include/nn/hac/nca.h

@@ -3,9 +3,11 @@
 #include <crypto/aes.h>
 #include <crypto/sha.h>
 #include <crypto/rsa.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace nca
 	{
@@ -127,8 +129,9 @@ namespace nx
 		byte_t signature_main[crypto::rsa::kRsa2048Size];
 		byte_t signature_acid[crypto::rsa::kRsa2048Size];
 		sNcaHeader header;
-		sNcaFsHeader fs_header[nx::nca::kPartitionNum];
+		sNcaFsHeader fs_header[nn::hac::nca::kPartitionNum];
 	};
 
 #pragma pack(pop)
 }
+}

lib/libhac/include/nn/hac/npdm.h

@@ -1,8 +1,10 @@
 #pragma once
 #include <fnd/types.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace npdm
 	{
@@ -51,4 +53,5 @@ namespace nx
 	};
 
 #pragma pack(pop)
+}
 }

lib/libhac/include/nn/hac/nro.h

@@ -1,8 +1,10 @@
 #pragma once
 #include <fnd/types.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace nro
 	{
@@ -40,3 +42,4 @@ namespace nx
 	};
 #pragma pack(pop)
 }
+}

lib/libhac/include/nn/hac/nrr.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <fnd/types.h>
 #include <crypto/rsa.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace nrr
 	{
@@ -34,3 +36,4 @@ namespace nx
 	};
 #pragma pack(pop)
 }
+}

lib/libhac/include/nn/hac/nso.h

@@ -1,9 +1,11 @@
 #pragma once
 #include <fnd/types.h>
 #include <crypto/sha.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace nso
 	{
@@ -63,3 +65,4 @@ namespace nx
 
 #pragma pack(pop)
 }
+}

lib/libhac/include/nn/hac/pfs.h

@@ -1,8 +1,10 @@
 #include <fnd/types.h>
 #include <crypto/sha.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace pfs
 	{
@@ -39,3 +41,4 @@ namespace nx
 	}; // sizeof(0x40)
 #pragma pack(pop)
 }
+}

lib/libhac/include/nn/hac/romfs.h

@@ -1,7 +1,9 @@
 #pragma once
 #include <fnd/types.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace romfs
 	{
@@ -55,3 +57,4 @@ namespace nx
 	};
 #pragma pack(pop)
 }
+}

lib/libhac/include/nn/hac/xci.h

@@ -4,9 +4,11 @@
 #include <crypto/aes.h>
 #include <crypto/sha.h>
 #include <crypto/rsa.h>
-#include <nx/macro.h>
+#include <nn/hac/macro.h>
 
-namespace nx
+namespace nn
+{
+namespace hac
 {
 	namespace xci
 	{
@@ -128,3 +130,4 @@ namespace nx
 
 #pragma pack(pop)
 }
+}

lib/libhac/source/AccessControlInfoBinary.cpp

@@ -1,16 +1,16 @@
-#include <nx/AccessControlInfoBinary.h>
+#include <nn/hac/AccessControlInfoBinary.h>
 
-nx::AccessControlInfoBinary::AccessControlInfoBinary()
+nn::hac::AccessControlInfoBinary::AccessControlInfoBinary()
 {
 	clear();
 }
 
-nx::AccessControlInfoBinary::AccessControlInfoBinary(const AccessControlInfoBinary & other)
+nn::hac::AccessControlInfoBinary::AccessControlInfoBinary(const AccessControlInfoBinary & other)
 {
 	*this = other;
 }
 
-void nx::AccessControlInfoBinary::operator=(const AccessControlInfoBinary & other)
+void nn::hac::AccessControlInfoBinary::operator=(const AccessControlInfoBinary & other)
 {
 	mRawBinary = other.mRawBinary;
 	mProgramId = other.mProgramId;
@@ -19,7 +19,7 @@ void nx::AccessControlInfoBinary::operator=(const AccessControlInfoBinary & othe
 	mKernelCapabilities = other.mKernelCapabilities;
 }
 
-bool nx::AccessControlInfoBinary::operator==(const AccessControlInfoBinary & other) const
+bool nn::hac::AccessControlInfoBinary::operator==(const AccessControlInfoBinary & other) const
 {
 	return (mProgramId == other.mProgramId) \
 		&& (mFileSystemAccessControl == other.mFileSystemAccessControl) \
@@ -27,12 +27,12 @@ bool nx::AccessControlInfoBinary::operator==(const AccessControlInfoBinary & oth
 		&& (mKernelCapabilities == other.mKernelCapabilities);
 }
 
-bool nx::AccessControlInfoBinary::operator!=(const AccessControlInfoBinary & other) const
+bool nn::hac::AccessControlInfoBinary::operator!=(const AccessControlInfoBinary & other) const
 {
 	return !(*this == other);
 }
 
-void nx::AccessControlInfoBinary::toBytes()
+void nn::hac::AccessControlInfoBinary::toBytes()
 {
 	if (mFileSystemAccessControl.getBytes().size() == 0)
 		mFileSystemAccessControl.toBytes();
@@ -76,7 +76,7 @@ void nx::AccessControlInfoBinary::toBytes()
 	hdr->kc.size = kc.size;
 }
 
-void nx::AccessControlInfoBinary::fromBytes(const byte_t* data, size_t len)
+void nn::hac::AccessControlInfoBinary::fromBytes(const byte_t* data, size_t len)
 {
 	// check size
 	if (len < sizeof(sAciHeader))
@@ -117,12 +117,12 @@ void nx::AccessControlInfoBinary::fromBytes(const byte_t* data, size_t len)
 	mKernelCapabilities.fromBytes(mRawBinary.data() + hdr.kc.offset.get(), hdr.kc.size.get());
 }
 
-const fnd::Vec<byte_t>& nx::AccessControlInfoBinary::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::AccessControlInfoBinary::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::AccessControlInfoBinary::clear()
+void nn::hac::AccessControlInfoBinary::clear()
 {
 	mRawBinary.clear();
 	mProgramId = 0;
@@ -131,42 +131,42 @@ void nx::AccessControlInfoBinary::clear()
 	mKernelCapabilities.clear();
 }
 
-uint64_t nx::AccessControlInfoBinary::getProgramId() const
+uint64_t nn::hac::AccessControlInfoBinary::getProgramId() const
 {
 	return mProgramId;
 }
 
-void nx::AccessControlInfoBinary::setProgramId(uint64_t program_id)
+void nn::hac::AccessControlInfoBinary::setProgramId(uint64_t program_id)
 {
 	mProgramId = program_id;
 }
 
-const nx::FileSystemAccessControlBinary& nx::AccessControlInfoBinary::getFileSystemAccessControl() const
+const nn::hac::FileSystemAccessControlBinary& nn::hac::AccessControlInfoBinary::getFileSystemAccessControl() const
 {
 	return mFileSystemAccessControl;
 }
 
-void nx::AccessControlInfoBinary::setFileSystemAccessControl(const nx::FileSystemAccessControlBinary& fac)
+void nn::hac::AccessControlInfoBinary::setFileSystemAccessControl(const nn::hac::FileSystemAccessControlBinary& fac)
 {
 	mFileSystemAccessControl = fac;
 }
 
-const nx::ServiceAccessControlBinary& nx::AccessControlInfoBinary::getServiceAccessControl() const
+const nn::hac::ServiceAccessControlBinary& nn::hac::AccessControlInfoBinary::getServiceAccessControl() const
 {
 	return mServiceAccessControl;
 }
 
-void nx::AccessControlInfoBinary::setServiceAccessControl(const nx::ServiceAccessControlBinary& sac)
+void nn::hac::AccessControlInfoBinary::setServiceAccessControl(const nn::hac::ServiceAccessControlBinary& sac)
 {
 	mServiceAccessControl = sac;
 }
 
-const nx::KernelCapabilityBinary& nx::AccessControlInfoBinary::getKernelCapabilities() const
+const nn::hac::KernelCapabilityBinary& nn::hac::AccessControlInfoBinary::getKernelCapabilities() const
 {
 	return mKernelCapabilities;
 }
 
-void nx::AccessControlInfoBinary::setKernelCapabilities(const nx::KernelCapabilityBinary& kc)
+void nn::hac::AccessControlInfoBinary::setKernelCapabilities(const nn::hac::KernelCapabilityBinary& kc)
 {
 	mKernelCapabilities = kc;
 }

lib/libhac/source/AccessControlInfoDescBinary.cpp

@@ -1,16 +1,16 @@
-#include <nx/AccessControlInfoDescBinary.h>
+#include <nn/hac/AccessControlInfoDescBinary.h>
 
-nx::AccessControlInfoDescBinary::AccessControlInfoDescBinary()
+nn::hac::AccessControlInfoDescBinary::AccessControlInfoDescBinary()
 {
 	clear();
 }
 
-nx::AccessControlInfoDescBinary::AccessControlInfoDescBinary(const AccessControlInfoDescBinary & other)
+nn::hac::AccessControlInfoDescBinary::AccessControlInfoDescBinary(const AccessControlInfoDescBinary & other)
 {
 	*this = other;
 }
 
-void nx::AccessControlInfoDescBinary::operator=(const AccessControlInfoDescBinary & other)
+void nn::hac::AccessControlInfoDescBinary::operator=(const AccessControlInfoDescBinary & other)
 {
 	mRawBinary = other.mRawBinary;
 	mNcaHeaderSignature2Key = other.mNcaHeaderSignature2Key;
@@ -21,7 +21,7 @@ void nx::AccessControlInfoDescBinary::operator=(const AccessControlInfoDescBinar
 	mKernelCapabilities = other.mKernelCapabilities;
 }
 
-bool nx::AccessControlInfoDescBinary::operator==(const AccessControlInfoDescBinary & other) const
+bool nn::hac::AccessControlInfoDescBinary::operator==(const AccessControlInfoDescBinary & other) const
 {
 	return (mNcaHeaderSignature2Key == other.mNcaHeaderSignature2Key) \
 		&& (mFlags == other.mFlags) \
@@ -31,12 +31,12 @@ bool nx::AccessControlInfoDescBinary::operator==(const AccessControlInfoDescBina
 		&& (mKernelCapabilities == other.mKernelCapabilities);
 }
 
-bool nx::AccessControlInfoDescBinary::operator!=(const AccessControlInfoDescBinary & other) const
+bool nn::hac::AccessControlInfoDescBinary::operator!=(const AccessControlInfoDescBinary & other) const
 {
 	return !(*this == other);
 }
 
-void nx::AccessControlInfoDescBinary::toBytes()
+void nn::hac::AccessControlInfoDescBinary::toBytes()
 {
 	if (mFileSystemAccessControl.getBytes().size() == 0)
 		mFileSystemAccessControl.toBytes();
@@ -93,7 +93,7 @@ void nx::AccessControlInfoDescBinary::toBytes()
 	hdr->kc.size = kc.size;
 }
 
-void nx::AccessControlInfoDescBinary::fromBytes(const byte_t* data, size_t len)
+void nn::hac::AccessControlInfoDescBinary::fromBytes(const byte_t* data, size_t len)
 {
 	// check size
 	if (len < sizeof(sAciDescHeader))
@@ -144,12 +144,12 @@ void nx::AccessControlInfoDescBinary::fromBytes(const byte_t* data, size_t len)
 	mKernelCapabilities.fromBytes(mRawBinary.data() + hdr.kc.offset.get(), hdr.kc.size.get());
 }
 
-const fnd::Vec<byte_t>& nx::AccessControlInfoDescBinary::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::AccessControlInfoDescBinary::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::AccessControlInfoDescBinary::generateSignature(const crypto::rsa::sRsa2048Key& key)
+void nn::hac::AccessControlInfoDescBinary::generateSignature(const crypto::rsa::sRsa2048Key& key)
 {
 	if (mRawBinary.size() == 0)
 		toBytes();
@@ -163,7 +163,7 @@ void nx::AccessControlInfoDescBinary::generateSignature(const crypto::rsa::sRsa2
 	}
 }
 
-void nx::AccessControlInfoDescBinary::validateSignature(const crypto::rsa::sRsa2048Key& key) const
+void nn::hac::AccessControlInfoDescBinary::validateSignature(const crypto::rsa::sRsa2048Key& key) const
 {
 	if (mRawBinary.size() == 0)
 		throw fnd::Exception(kModuleName, "No Access Control Info Desc binary exists to verify");
@@ -177,7 +177,7 @@ void nx::AccessControlInfoDescBinary::validateSignature(const crypto::rsa::sRsa2
 	}
 }
 
-void nx::AccessControlInfoDescBinary::clear()
+void nn::hac::AccessControlInfoDescBinary::clear()
 {
 	mRawBinary.clear();
 	memset((void*)&mNcaHeaderSignature2Key, 0, sizeof(mNcaHeaderSignature2Key));
@@ -189,62 +189,62 @@ void nx::AccessControlInfoDescBinary::clear()
 	mKernelCapabilities.clear();
 }
 
-const crypto::rsa::sRsa2048Key& nx::AccessControlInfoDescBinary::getNcaHeaderSignature2Key() const
+const crypto::rsa::sRsa2048Key& nn::hac::AccessControlInfoDescBinary::getNcaHeaderSignature2Key() const
 {
 	return mNcaHeaderSignature2Key;
 }
 
-void nx::AccessControlInfoDescBinary::setNcaHeaderSignature2Key(const crypto::rsa::sRsa2048Key& key)
+void nn::hac::AccessControlInfoDescBinary::setNcaHeaderSignature2Key(const crypto::rsa::sRsa2048Key& key)
 {
 	mNcaHeaderSignature2Key = key;
 }
 
-const fnd::List<nx::aci::Flag>& nx::AccessControlInfoDescBinary::getFlagList() const
+const fnd::List<nn::hac::aci::Flag>& nn::hac::AccessControlInfoDescBinary::getFlagList() const
 {
 	return mFlags;
 }
 
-void nx::AccessControlInfoDescBinary::setFlagList(const fnd::List<nx::aci::Flag>& flags)
+void nn::hac::AccessControlInfoDescBinary::setFlagList(const fnd::List<nn::hac::aci::Flag>& flags)
 {
 	mFlags = flags;
 }
 
-const nx::AccessControlInfoDescBinary::sProgramIdRestrict&  nx::AccessControlInfoDescBinary::getProgramIdRestrict() const
+const nn::hac::AccessControlInfoDescBinary::sProgramIdRestrict&  nn::hac::AccessControlInfoDescBinary::getProgramIdRestrict() const
 {
 	return mProgramIdRestrict;
 }
 
-void nx::AccessControlInfoDescBinary::setProgramIdRestrict(const sProgramIdRestrict& pid_restrict)
+void nn::hac::AccessControlInfoDescBinary::setProgramIdRestrict(const sProgramIdRestrict& pid_restrict)
 {
 	mProgramIdRestrict = pid_restrict;
 }
 
-const nx::FileSystemAccessControlBinary& nx::AccessControlInfoDescBinary::getFileSystemAccessControl() const
+const nn::hac::FileSystemAccessControlBinary& nn::hac::AccessControlInfoDescBinary::getFileSystemAccessControl() const
 {
 	return mFileSystemAccessControl;
 }
 
-void nx::AccessControlInfoDescBinary::setFileSystemAccessControl(const nx::FileSystemAccessControlBinary& fac)
+void nn::hac::AccessControlInfoDescBinary::setFileSystemAccessControl(const nn::hac::FileSystemAccessControlBinary& fac)
 {
 	mFileSystemAccessControl = fac;
 }
 
-const nx::ServiceAccessControlBinary& nx::AccessControlInfoDescBinary::getServiceAccessControl() const
+const nn::hac::ServiceAccessControlBinary& nn::hac::AccessControlInfoDescBinary::getServiceAccessControl() const
 {
 	return mServiceAccessControl;
 }
 
-void nx::AccessControlInfoDescBinary::setServiceAccessControl(const nx::ServiceAccessControlBinary& sac)
+void nn::hac::AccessControlInfoDescBinary::setServiceAccessControl(const nn::hac::ServiceAccessControlBinary& sac)
 {
 	mServiceAccessControl = sac;
 }
 
-const nx::KernelCapabilityBinary& nx::AccessControlInfoDescBinary::getKernelCapabilities() const
+const nn::hac::KernelCapabilityBinary& nn::hac::AccessControlInfoDescBinary::getKernelCapabilities() const
 {
 	return mKernelCapabilities;
 }
 
-void nx::AccessControlInfoDescBinary::setKernelCapabilities(const nx::KernelCapabilityBinary& kc)
+void nn::hac::AccessControlInfoDescBinary::setKernelCapabilities(const nn::hac::KernelCapabilityBinary& kc)
 {
 	mKernelCapabilities = kc;
 }

lib/libhac/source/AesKeygen.cpp

@@ -1,17 +1,17 @@
-#include <nx/AesKeygen.h>
+#include <nn/hac/AesKeygen.h>
 
-void nx::AesKeygen::generateKey(byte_t* dst, const byte_t* src, const byte_t* src_key)
+void nn::hac::AesKeygen::generateKey(byte_t* dst, const byte_t* src, const byte_t* src_key)
 {
 	crypto::aes::AesEcbDecrypt(src, sizeof(crypto::aes::sAes128Key), src_key, dst);
 }
 
-void nx::AesKeygen::generateKey(byte_t* dst, const byte_t* src1, const byte_t* src2, const byte_t* src1_key)
+void nn::hac::AesKeygen::generateKey(byte_t* dst, const byte_t* src1, const byte_t* src2, const byte_t* src1_key)
 {
 	crypto::aes::sAes128Key src2_key;
 	generateKey(src2_key.key, src1, src1_key);
 	generateKey(dst, src2, src2_key.key);
 }
-void nx::AesKeygen::generateKey(byte_t* dst, const byte_t* src1, const byte_t* src2, const byte_t* src3, const byte_t* src1_key)
+void nn::hac::AesKeygen::generateKey(byte_t* dst, const byte_t* src1, const byte_t* src2, const byte_t* src3, const byte_t* src1_key)
 {
 	crypto::aes::sAes128Key src3_key;
 	generateKey(src3_key.key, src1, src2, src1_key);

lib/libhac/source/ApplicationControlPropertyBinary.cpp

@@ -1,16 +1,16 @@
-#include <nx/ApplicationControlPropertyBinary.h>
+#include <nn/hac/ApplicationControlPropertyBinary.h>
 
-nx::ApplicationControlPropertyBinary::ApplicationControlPropertyBinary()
+nn::hac::ApplicationControlPropertyBinary::ApplicationControlPropertyBinary()
 {
 	clear();
 }
 
-nx::ApplicationControlPropertyBinary::ApplicationControlPropertyBinary(const ApplicationControlPropertyBinary& other)
+nn::hac::ApplicationControlPropertyBinary::ApplicationControlPropertyBinary(const ApplicationControlPropertyBinary& other)
 {
 	*this = other;
 }
 
-void nx::ApplicationControlPropertyBinary::operator=(const ApplicationControlPropertyBinary& other)
+void nn::hac::ApplicationControlPropertyBinary::operator=(const ApplicationControlPropertyBinary& other)
 {
 	clear();
 	mTitle = other.mTitle;
@@ -54,7 +54,7 @@ void nx::ApplicationControlPropertyBinary::operator=(const ApplicationControlPro
 	mProgramIndex = other.mProgramIndex;
 }
 
-bool nx::ApplicationControlPropertyBinary::operator==(const ApplicationControlPropertyBinary& other) const
+bool nn::hac::ApplicationControlPropertyBinary::operator==(const ApplicationControlPropertyBinary& other) const
 {
 	return (mTitle == other.mTitle) \
 		&& (mIsbn == other.mIsbn) \
@@ -97,14 +97,14 @@ bool nx::ApplicationControlPropertyBinary::operator==(const ApplicationControlPr
 		&& (mProgramIndex == other.mProgramIndex);
 }
 
-bool nx::ApplicationControlPropertyBinary::operator!=(const ApplicationControlPropertyBinary& other) const
+bool nn::hac::ApplicationControlPropertyBinary::operator!=(const ApplicationControlPropertyBinary& other) const
 {
 	return !(*this == other);
 }
 
-void nx::ApplicationControlPropertyBinary::toBytes()
+void nn::hac::ApplicationControlPropertyBinary::toBytes()
 {
-	mRawBinary.alloc(sizeof(nx::sApplicationControlProperty));
+	mRawBinary.alloc(sizeof(nn::hac::sApplicationControlProperty));
 
 	sApplicationControlProperty* data = (sApplicationControlProperty*)mRawBinary.data();
 
@@ -182,16 +182,16 @@ void nx::ApplicationControlPropertyBinary::toBytes()
 	data->cache_storage_data_and_journal_size_max = mCacheStorageDataAndJournalSizeMax;
 }
 
-void nx::ApplicationControlPropertyBinary::fromBytes(const byte_t* bytes, size_t len)
+void nn::hac::ApplicationControlPropertyBinary::fromBytes(const byte_t* bytes, size_t len)
 {
-	if (len < sizeof(nx::sApplicationControlProperty))
+	if (len < sizeof(nn::hac::sApplicationControlProperty))
 	{
 		throw fnd::Exception(kModuleName, "NACP too small");
 	}
 
 	clear();
 
-	mRawBinary.alloc(sizeof(nx::sApplicationControlProperty));
+	mRawBinary.alloc(sizeof(nn::hac::sApplicationControlProperty));
 	memcpy(mRawBinary.data(), bytes, mRawBinary.size());
 
 	const sApplicationControlProperty* data = (const sApplicationControlProperty*)mRawBinary.data();
@@ -275,12 +275,12 @@ void nx::ApplicationControlPropertyBinary::fromBytes(const byte_t* bytes, size_t
 	mCacheStorageDataAndJournalSizeMax = (int64_t)data->cache_storage_data_and_journal_size_max.get();
 }
 
-const fnd::Vec<byte_t>& nx::ApplicationControlPropertyBinary::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::ApplicationControlPropertyBinary::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::ApplicationControlPropertyBinary::clear()
+void nn::hac::ApplicationControlPropertyBinary::clear()
 {
 	mRawBinary.clear();
 	mTitle.clear();
@@ -324,392 +324,392 @@ void nx::ApplicationControlPropertyBinary::clear()
 	mProgramIndex = 0;
 }
 
-const fnd::List<nx::ApplicationControlPropertyBinary::sTitle>& nx::ApplicationControlPropertyBinary::getTitle() const
+const fnd::List<nn::hac::ApplicationControlPropertyBinary::sTitle>& nn::hac::ApplicationControlPropertyBinary::getTitle() const
 {
 	return mTitle;
 }
 
-void nx::ApplicationControlPropertyBinary::setTitle(const fnd::List<sTitle>& title)
+void nn::hac::ApplicationControlPropertyBinary::setTitle(const fnd::List<sTitle>& title)
 {
 	mTitle = title;
 }
 
-const std::string& nx::ApplicationControlPropertyBinary::getIsbn() const
+const std::string& nn::hac::ApplicationControlPropertyBinary::getIsbn() const
 {
 	return mIsbn;
 }
 
-void nx::ApplicationControlPropertyBinary::setIsbn(const std::string& isbn)
+void nn::hac::ApplicationControlPropertyBinary::setIsbn(const std::string& isbn)
 {
 	mIsbn = isbn;
 }
 
-nx::nacp::StartupUserAccount nx::ApplicationControlPropertyBinary::getStartupUserAccount() const
+nn::hac::nacp::StartupUserAccount nn::hac::ApplicationControlPropertyBinary::getStartupUserAccount() const
 {
 	return mStartupUserAccount;
 }
 
-void nx::ApplicationControlPropertyBinary::setStartupUserAccount(nacp::StartupUserAccount var)
+void nn::hac::ApplicationControlPropertyBinary::setStartupUserAccount(nacp::StartupUserAccount var)
 {
 	mStartupUserAccount = var;
 }
 
-nx::nacp::TouchScreenUsageMode nx::ApplicationControlPropertyBinary::getTouchScreenUsageMode() const
+nn::hac::nacp::TouchScreenUsageMode nn::hac::ApplicationControlPropertyBinary::getTouchScreenUsageMode() const
 {
 	return mTouchScreenUsageMode;
 }
 
-void nx::ApplicationControlPropertyBinary::setTouchScreenUsageMode(nacp::TouchScreenUsageMode var)
+void nn::hac::ApplicationControlPropertyBinary::setTouchScreenUsageMode(nacp::TouchScreenUsageMode var)
 {
 	mTouchScreenUsageMode = var;
 }
 
-nx::nacp::AocRegistrationType nx::ApplicationControlPropertyBinary::getAocRegistrationType() const
+nn::hac::nacp::AocRegistrationType nn::hac::ApplicationControlPropertyBinary::getAocRegistrationType() const
 {
 	return mAocRegistrationType;
 }
 
-void nx::ApplicationControlPropertyBinary::setAocRegistrationType(nacp::AocRegistrationType var)
+void nn::hac::ApplicationControlPropertyBinary::setAocRegistrationType(nacp::AocRegistrationType var)
 {
 	mAocRegistrationType = var;
 }
 
-nx::nacp::AttributeFlag nx::ApplicationControlPropertyBinary::getAttributeFlag() const
+nn::hac::nacp::AttributeFlag nn::hac::ApplicationControlPropertyBinary::getAttributeFlag() const
 {
 	return mAttributeFlag;
 }
 
-void nx::ApplicationControlPropertyBinary::setAttributeFlag(nacp::AttributeFlag var)
+void nn::hac::ApplicationControlPropertyBinary::setAttributeFlag(nacp::AttributeFlag var)
 {
 	mAttributeFlag = var;
 }
 
-const fnd::List<nx::nacp::Language>& nx::ApplicationControlPropertyBinary::getSupportedLanguages() const
+const fnd::List<nn::hac::nacp::Language>& nn::hac::ApplicationControlPropertyBinary::getSupportedLanguages() const
 {
 	return mSupportedLanguages;
 }
 
-void nx::ApplicationControlPropertyBinary::setSupportedLanguages(const fnd::List<nacp::Language>& var)
+void nn::hac::ApplicationControlPropertyBinary::setSupportedLanguages(const fnd::List<nacp::Language>& var)
 {
 	mSupportedLanguages = var;
 }
 
-nx::nacp::ParentalControlFlag nx::ApplicationControlPropertyBinary::getParentalControlFlag() const
+nn::hac::nacp::ParentalControlFlag nn::hac::ApplicationControlPropertyBinary::getParentalControlFlag() const
 {
 	return mParentalControlFlag;
 }
 
-void nx::ApplicationControlPropertyBinary::setParentalControlFlag(nacp::ParentalControlFlag var)
+void nn::hac::ApplicationControlPropertyBinary::setParentalControlFlag(nacp::ParentalControlFlag var)
 {
 	mParentalControlFlag = var;
 }
 
-nx::nacp::ScreenshotMode nx::ApplicationControlPropertyBinary::getScreenshotMode() const
+nn::hac::nacp::ScreenshotMode nn::hac::ApplicationControlPropertyBinary::getScreenshotMode() const
 {
 	return mScreenshotMode;
 }
 
-void nx::ApplicationControlPropertyBinary::setScreenshotMode(nacp::ScreenshotMode var)
+void nn::hac::ApplicationControlPropertyBinary::setScreenshotMode(nacp::ScreenshotMode var)
 {
 	mScreenshotMode = var;
 }
 
-nx::nacp::VideoCaptureMode nx::ApplicationControlPropertyBinary::getVideoCaptureMode() const
+nn::hac::nacp::VideoCaptureMode nn::hac::ApplicationControlPropertyBinary::getVideoCaptureMode() const
 {
 	return mVideoCaptureMode;
 }
 
-void nx::ApplicationControlPropertyBinary::setVideoCaptureMode(nacp::VideoCaptureMode var)
+void nn::hac::ApplicationControlPropertyBinary::setVideoCaptureMode(nacp::VideoCaptureMode var)
 {
 	mVideoCaptureMode = var;
 }
 
-nx::nacp::DataLossConfirmation nx::ApplicationControlPropertyBinary::getDataLossConfirmation() const
+nn::hac::nacp::DataLossConfirmation nn::hac::ApplicationControlPropertyBinary::getDataLossConfirmation() const
 {
 	return mDataLossConfirmation;
 }
 
-void nx::ApplicationControlPropertyBinary::setDataLossConfirmation(nacp::DataLossConfirmation var)
+void nn::hac::ApplicationControlPropertyBinary::setDataLossConfirmation(nacp::DataLossConfirmation var)
 {
 	mDataLossConfirmation = var;
 }
 
-nx::nacp::PlayLogPolicy nx::ApplicationControlPropertyBinary::getPlayLogPolicy() const
+nn::hac::nacp::PlayLogPolicy nn::hac::ApplicationControlPropertyBinary::getPlayLogPolicy() const
 {
 	return mPlayLogPolicy;
 }
 
-void nx::ApplicationControlPropertyBinary::setPlayLogPolicy(nacp::PlayLogPolicy var)
+void nn::hac::ApplicationControlPropertyBinary::setPlayLogPolicy(nacp::PlayLogPolicy var)
 {
 	mPlayLogPolicy = var;
 }
 
-uint64_t nx::ApplicationControlPropertyBinary::getPresenceGroupId() const
+uint64_t nn::hac::ApplicationControlPropertyBinary::getPresenceGroupId() const
 {
 	return mPresenceGroupId;
 }
 
-void nx::ApplicationControlPropertyBinary::setPresenceGroupId(uint64_t var)
+void nn::hac::ApplicationControlPropertyBinary::setPresenceGroupId(uint64_t var)
 {
 	mPresenceGroupId = var;
 }
 
-const fnd::List<nx::ApplicationControlPropertyBinary::sRating>& nx::ApplicationControlPropertyBinary::getRatingAge() const
+const fnd::List<nn::hac::ApplicationControlPropertyBinary::sRating>& nn::hac::ApplicationControlPropertyBinary::getRatingAge() const
 {
 	return mRatingAge;
 }
 
-void nx::ApplicationControlPropertyBinary::setRatingAge(const fnd::List<sRating>& var)
+void nn::hac::ApplicationControlPropertyBinary::setRatingAge(const fnd::List<sRating>& var)
 {
 	mRatingAge = var;
 }
 
-const std::string& nx::ApplicationControlPropertyBinary::getDisplayVersion() const
+const std::string& nn::hac::ApplicationControlPropertyBinary::getDisplayVersion() const
 {
 	return mDisplayVersion;
 }
 
-void nx::ApplicationControlPropertyBinary::setDisplayVersion(const std::string& var)
+void nn::hac::ApplicationControlPropertyBinary::setDisplayVersion(const std::string& var)
 {
 	mDisplayVersion = var;
 }
 
-uint64_t nx::ApplicationControlPropertyBinary::getAocBaseId() const
+uint64_t nn::hac::ApplicationControlPropertyBinary::getAocBaseId() const
 {
 	return mAocBaseId;
 }
 
-void nx::ApplicationControlPropertyBinary::setAocBaseId(uint64_t var)
+void nn::hac::ApplicationControlPropertyBinary::setAocBaseId(uint64_t var)
 {
 	mAocBaseId = var;
 }
 
-uint64_t nx::ApplicationControlPropertyBinary::getSaveDatawOwnerId() const
+uint64_t nn::hac::ApplicationControlPropertyBinary::getSaveDatawOwnerId() const
 {
 	return mSaveDatawOwnerId;
 }
 
-void nx::ApplicationControlPropertyBinary::setSaveDatawOwnerId(uint64_t var)
+void nn::hac::ApplicationControlPropertyBinary::setSaveDatawOwnerId(uint64_t var)
 {
 	mSaveDatawOwnerId = var;
 }
 
-const nx::ApplicationControlPropertyBinary::sStorageSize& nx::ApplicationControlPropertyBinary::getUserAccountSaveDataSize() const
+const nn::hac::ApplicationControlPropertyBinary::sStorageSize& nn::hac::ApplicationControlPropertyBinary::getUserAccountSaveDataSize() const
 {
 	return mUserAccountSaveDataSize;
 }
 
-void nx::ApplicationControlPropertyBinary::setUserAccountSaveDataSize(const sStorageSize& var)
+void nn::hac::ApplicationControlPropertyBinary::setUserAccountSaveDataSize(const sStorageSize& var)
 {
 	mUserAccountSaveDataSize = var;
 }
 
-const nx::ApplicationControlPropertyBinary::sStorageSize& nx::ApplicationControlPropertyBinary::getDeviceSaveDataSize() const
+const nn::hac::ApplicationControlPropertyBinary::sStorageSize& nn::hac::ApplicationControlPropertyBinary::getDeviceSaveDataSize() const
 {
 	return mDeviceSaveDataSize;
 }
 
-void nx::ApplicationControlPropertyBinary::setDeviceSaveDataSize(const sStorageSize& var)
+void nn::hac::ApplicationControlPropertyBinary::setDeviceSaveDataSize(const sStorageSize& var)
 {
 	mDeviceSaveDataSize = var;
 }
 
-int64_t nx::ApplicationControlPropertyBinary::getBcatDeliveryCacheStorageSize() const
+int64_t nn::hac::ApplicationControlPropertyBinary::getBcatDeliveryCacheStorageSize() const
 {
 	return mBcatDeliveryCacheStorageSize;
 }
 
-void nx::ApplicationControlPropertyBinary::setBcatDeliveryCacheStorageSize(int64_t var)
+void nn::hac::ApplicationControlPropertyBinary::setBcatDeliveryCacheStorageSize(int64_t var)
 {
 	mBcatDeliveryCacheStorageSize = var;
 }
 
-const std::string& nx::ApplicationControlPropertyBinary::getApplicationErrorCodeCategory() const
+const std::string& nn::hac::ApplicationControlPropertyBinary::getApplicationErrorCodeCategory() const
 {
 	return mApplicationErrorCodeCategory;
 }
 
-void nx::ApplicationControlPropertyBinary::setApplicationErrorCodeCategory(const std::string& var)
+void nn::hac::ApplicationControlPropertyBinary::setApplicationErrorCodeCategory(const std::string& var)
 {
 	mApplicationErrorCodeCategory = var;
 }
 
-const fnd::List<uint64_t>& nx::ApplicationControlPropertyBinary::getLocalCommunicationId() const
+const fnd::List<uint64_t>& nn::hac::ApplicationControlPropertyBinary::getLocalCommunicationId() const
 {
 	return mLocalCommunicationId;
 }
 
-void nx::ApplicationControlPropertyBinary::setLocalCommunicationId(const fnd::List<uint64_t>& var)
+void nn::hac::ApplicationControlPropertyBinary::setLocalCommunicationId(const fnd::List<uint64_t>& var)
 {
 	mLocalCommunicationId = var;
 }
 
-nx::nacp::LogoType nx::ApplicationControlPropertyBinary::getLogoType() const
+nn::hac::nacp::LogoType nn::hac::ApplicationControlPropertyBinary::getLogoType() const
 {
 	return mLogoType;
 }
 
-void nx::ApplicationControlPropertyBinary::setLogoType(nacp::LogoType var)
+void nn::hac::ApplicationControlPropertyBinary::setLogoType(nacp::LogoType var)
 {
 	mLogoType = var;
 }
 
-nx::nacp::LogoHandling nx::ApplicationControlPropertyBinary::getLogoHandling() const
+nn::hac::nacp::LogoHandling nn::hac::ApplicationControlPropertyBinary::getLogoHandling() const
 {
 	return mLogoHandling;
 }
 
-void nx::ApplicationControlPropertyBinary::setLogoHandling(nacp::LogoHandling var)
+void nn::hac::ApplicationControlPropertyBinary::setLogoHandling(nacp::LogoHandling var)
 {
 	mLogoHandling = var;
 }
 
-nx::nacp::RuntimeAocInstallMode nx::ApplicationControlPropertyBinary::getRuntimeAocInstallMode() const
+nn::hac::nacp::RuntimeAocInstallMode nn::hac::ApplicationControlPropertyBinary::getRuntimeAocInstallMode() const
 {
 	return mRuntimeAocInstallMode;
 }
 
-void nx::ApplicationControlPropertyBinary::setRuntimeAocInstallMode(nacp::RuntimeAocInstallMode var)
+void nn::hac::ApplicationControlPropertyBinary::setRuntimeAocInstallMode(nacp::RuntimeAocInstallMode var)
 {
 	mRuntimeAocInstallMode = var;
 }
 
-nx::nacp::CrashReportMode nx::ApplicationControlPropertyBinary::getCrashReportMode() const
+nn::hac::nacp::CrashReportMode nn::hac::ApplicationControlPropertyBinary::getCrashReportMode() const
 {
 	return mCrashReportMode;
 }
 
-void nx::ApplicationControlPropertyBinary::setCrashReportMode(nacp::CrashReportMode var)
+void nn::hac::ApplicationControlPropertyBinary::setCrashReportMode(nacp::CrashReportMode var)
 {
 	mCrashReportMode = var;
 }
 
-nx::nacp::Hdcp nx::ApplicationControlPropertyBinary::getHdcp() const
+nn::hac::nacp::Hdcp nn::hac::ApplicationControlPropertyBinary::getHdcp() const
 {
 	return mHdcp;
 }
 
-void nx::ApplicationControlPropertyBinary::setHdcp(nacp::Hdcp var)
+void nn::hac::ApplicationControlPropertyBinary::setHdcp(nacp::Hdcp var)
 {
 	mHdcp = var;
 }
 
-uint64_t nx::ApplicationControlPropertyBinary::getSeedForPsuedoDeviceId() const
+uint64_t nn::hac::ApplicationControlPropertyBinary::getSeedForPsuedoDeviceId() const
 {
 	return mSeedForPsuedoDeviceId;
 }
 
-void nx::ApplicationControlPropertyBinary::setSeedForPsuedoDeviceId(uint64_t var)
+void nn::hac::ApplicationControlPropertyBinary::setSeedForPsuedoDeviceId(uint64_t var)
 {
 	mSeedForPsuedoDeviceId = var;
 }
 
-const std::string& nx::ApplicationControlPropertyBinary::getBcatPassphase() const
+const std::string& nn::hac::ApplicationControlPropertyBinary::getBcatPassphase() const
 {
 	return mBcatPassphase;
 }
 
-void nx::ApplicationControlPropertyBinary::setBcatPassphase(const std::string& var)
+void nn::hac::ApplicationControlPropertyBinary::setBcatPassphase(const std::string& var)
 {
 	mBcatPassphase = var;
 }
 
-const nx::ApplicationControlPropertyBinary::sStorageSize& nx::ApplicationControlPropertyBinary::getUserAccountSaveDataMax() const
+const nn::hac::ApplicationControlPropertyBinary::sStorageSize& nn::hac::ApplicationControlPropertyBinary::getUserAccountSaveDataMax() const
 {
 	return mUserAccountSaveDataMax;
 }
 
-void nx::ApplicationControlPropertyBinary::setUserAccountSaveDataMax(const sStorageSize& var)
+void nn::hac::ApplicationControlPropertyBinary::setUserAccountSaveDataMax(const sStorageSize& var)
 {
 	mUserAccountSaveDataMax = var;
 }
 
-const nx::ApplicationControlPropertyBinary::sStorageSize& nx::ApplicationControlPropertyBinary::getDeviceSaveDataMax() const
+const nn::hac::ApplicationControlPropertyBinary::sStorageSize& nn::hac::ApplicationControlPropertyBinary::getDeviceSaveDataMax() const
 {
 	return mDeviceSaveDataMax;
 }
 
-void nx::ApplicationControlPropertyBinary::setDeviceSaveDataMax(const sStorageSize& var)
+void nn::hac::ApplicationControlPropertyBinary::setDeviceSaveDataMax(const sStorageSize& var)
 {
 	mDeviceSaveDataMax = var;
 }
 
-int64_t nx::ApplicationControlPropertyBinary::getTemporaryStorageSize() const
+int64_t nn::hac::ApplicationControlPropertyBinary::getTemporaryStorageSize() const
 {
 	return mTemporaryStorageSize;
 }
 
-void nx::ApplicationControlPropertyBinary::setTemporaryStorageSize(int64_t var)
+void nn::hac::ApplicationControlPropertyBinary::setTemporaryStorageSize(int64_t var)
 {
 	mTemporaryStorageSize = var;
 }
 
-const nx::ApplicationControlPropertyBinary::sStorageSize& nx::ApplicationControlPropertyBinary::getCacheStorageSize() const
+const nn::hac::ApplicationControlPropertyBinary::sStorageSize& nn::hac::ApplicationControlPropertyBinary::getCacheStorageSize() const
 {
 	return mCacheStorageSize;
 }
 
-void nx::ApplicationControlPropertyBinary::setCacheStorageSize(const sStorageSize& var)
+void nn::hac::ApplicationControlPropertyBinary::setCacheStorageSize(const sStorageSize& var)
 {
 	mCacheStorageSize = var;
 }
 
-int64_t nx::ApplicationControlPropertyBinary::getCacheStorageDataAndJournalSizeMax() const
+int64_t nn::hac::ApplicationControlPropertyBinary::getCacheStorageDataAndJournalSizeMax() const
 {
 	return mCacheStorageDataAndJournalSizeMax;
 }
 
-void nx::ApplicationControlPropertyBinary::setCacheStorageDataAndJournalSizeMax(int64_t var)
+void nn::hac::ApplicationControlPropertyBinary::setCacheStorageDataAndJournalSizeMax(int64_t var)
 {
 	mCacheStorageDataAndJournalSizeMax = var;
 }
 
-uint16_t nx::ApplicationControlPropertyBinary::getCacheStorageIndexMax() const
+uint16_t nn::hac::ApplicationControlPropertyBinary::getCacheStorageIndexMax() const
 {
 	return mCacheStorageIndexMax;
 }
 
-void nx::ApplicationControlPropertyBinary::setCacheStorageIndexMax(uint16_t var)
+void nn::hac::ApplicationControlPropertyBinary::setCacheStorageIndexMax(uint16_t var)
 {
 	mCacheStorageIndexMax = var;
 }
 
-const fnd::List<uint64_t>& nx::ApplicationControlPropertyBinary::getPlayLogQueryableApplicationId() const
+const fnd::List<uint64_t>& nn::hac::ApplicationControlPropertyBinary::getPlayLogQueryableApplicationId() const
 {
 	return mPlayLogQueryableApplicationId;
 }
 
-void nx::ApplicationControlPropertyBinary::setPlayLogQueryableApplicationId(const fnd::List<uint64_t>& var)
+void nn::hac::ApplicationControlPropertyBinary::setPlayLogQueryableApplicationId(const fnd::List<uint64_t>& var)
 {
 	mPlayLogQueryableApplicationId = var;
 }
 
-nx::nacp::PlayLogQueryCapability nx::ApplicationControlPropertyBinary::getPlayLogQueryCapability() const
+nn::hac::nacp::PlayLogQueryCapability nn::hac::ApplicationControlPropertyBinary::getPlayLogQueryCapability() const
 {
 	return mPlayLogQueryCapability;
 }
 
-void nx::ApplicationControlPropertyBinary::setPlayLogQueryCapability(nacp::PlayLogQueryCapability var)
+void nn::hac::ApplicationControlPropertyBinary::setPlayLogQueryCapability(nacp::PlayLogQueryCapability var)
 {
 	mPlayLogQueryCapability = var;
 }
 
-nx::nacp::RepairFlag nx::ApplicationControlPropertyBinary::getRepairFlag() const
+nn::hac::nacp::RepairFlag nn::hac::ApplicationControlPropertyBinary::getRepairFlag() const
 {
 	return mRepairFlag;
 }
 
-void nx::ApplicationControlPropertyBinary::setRepairFlag(nacp::RepairFlag var)
+void nn::hac::ApplicationControlPropertyBinary::setRepairFlag(nacp::RepairFlag var)
 {
 	mRepairFlag = var;
 }
 
-byte_t nx::ApplicationControlPropertyBinary::getProgramIndex() const
+byte_t nn::hac::ApplicationControlPropertyBinary::getProgramIndex() const
 {
 	return mProgramIndex;
 }
 
-void nx::ApplicationControlPropertyBinary::setProgramIndex(byte_t var)
+void nn::hac::ApplicationControlPropertyBinary::setProgramIndex(byte_t var)
 {
 	mProgramIndex = var;
 }

lib/libhac/source/ApplicationControlPropertyUtils.cpp

@@ -1,11 +1,11 @@
-#include <nx/ApplicationControlPropertyUtils.h>
+#include <nn/hac/ApplicationControlPropertyUtils.h>
 
-bool nx::ApplicationControlPropertyUtils::validateSaveDataSizeMax(int64_t size, int64_t alignment)
+bool nn::hac::ApplicationControlPropertyUtils::validateSaveDataSizeMax(int64_t size, int64_t alignment)
 {
 	return (alignment != 0 && (size & (alignment - 1)) != 0) == false;
 }
 
-bool nx::ApplicationControlPropertyUtils::validateSaveDataSize(int64_t size)
+bool nn::hac::ApplicationControlPropertyUtils::validateSaveDataSize(int64_t size)
 {
 	return (size & 0x3fff) == 0;
 }

lib/libhac/source/ContentMetaBinary.cpp

@@ -1,16 +1,16 @@
-#include <nx/ContentMetaBinary.h>
+#include <nn/hac/ContentMetaBinary.h>
 
-nx::ContentMetaBinary::ContentMetaBinary()
+nn::hac::ContentMetaBinary::ContentMetaBinary()
 {
 	clear();
 }
 
-nx::ContentMetaBinary::ContentMetaBinary(const ContentMetaBinary & other)
+nn::hac::ContentMetaBinary::ContentMetaBinary(const ContentMetaBinary & other)
 {
 	*this = other;
 }
 
-void nx::ContentMetaBinary::operator=(const ContentMetaBinary& other)
+void nn::hac::ContentMetaBinary::operator=(const ContentMetaBinary& other)
 {
 	if (other.getBytes().size() > 0)
 	{
@@ -36,7 +36,7 @@ void nx::ContentMetaBinary::operator=(const ContentMetaBinary& other)
 	}
 }
 
-bool nx::ContentMetaBinary::operator==(const ContentMetaBinary& other) const
+bool nn::hac::ContentMetaBinary::operator==(const ContentMetaBinary& other) const
 {
 	return (mTitleId == other.mTitleId) \
 		&& (mTitleVersion == other.mTitleVersion) \
@@ -54,17 +54,17 @@ bool nx::ContentMetaBinary::operator==(const ContentMetaBinary& other) const
 		&& (memcmp(mDigest.data, other.mDigest.data, cnmt::kDigestLen) == 0);
 }
 
-bool nx::ContentMetaBinary::operator!=(const ContentMetaBinary& other) const
+bool nn::hac::ContentMetaBinary::operator!=(const ContentMetaBinary& other) const
 {
 	return !(*this == other);
 }
 
-void nx::ContentMetaBinary::toBytes()
+void nn::hac::ContentMetaBinary::toBytes()
 {
 	throw fnd::Exception(kModuleName, "exportBinary() not implemented");
 }
 
-void nx::ContentMetaBinary::fromBytes(const byte_t* data, size_t len)
+void nn::hac::ContentMetaBinary::fromBytes(const byte_t* data, size_t len)
 {
 	// clear member variables
 	clear();
@@ -153,12 +153,12 @@ void nx::ContentMetaBinary::fromBytes(const byte_t* data, size_t len)
 	memcpy(mDigest.data, data + getDigestOffset(hdr->exhdr_size.get(), hdr->content_count.get(), hdr->content_meta_count.get(), exdata_size), cnmt::kDigestLen);
 }
 
-const fnd::Vec<byte_t>& nx::ContentMetaBinary::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::ContentMetaBinary::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::ContentMetaBinary::clear()
+void nn::hac::ContentMetaBinary::clear()
 {
 	mRawBinary.clear();
 	mTitleId = 0;
@@ -177,138 +177,138 @@ void nx::ContentMetaBinary::clear()
 	memset(mDigest.data, 0, cnmt::kDigestLen);
 }
 
-uint64_t nx::ContentMetaBinary::getTitleId() const
+uint64_t nn::hac::ContentMetaBinary::getTitleId() const
 {
 	return mTitleId;
 }
 
-void nx::ContentMetaBinary::setTitleId(uint64_t title_id)
+void nn::hac::ContentMetaBinary::setTitleId(uint64_t title_id)
 {
 	mTitleId = title_id;
 }
 
-uint32_t nx::ContentMetaBinary::getTitleVersion() const
+uint32_t nn::hac::ContentMetaBinary::getTitleVersion() const
 {
 	return mTitleVersion;
 }
 
-void nx::ContentMetaBinary::setTitleVersion(uint32_t version)
+void nn::hac::ContentMetaBinary::setTitleVersion(uint32_t version)
 {
 	mTitleVersion = version;
 }
 
-nx::cnmt::ContentMetaType nx::ContentMetaBinary::getType() const
+nn::hac::cnmt::ContentMetaType nn::hac::ContentMetaBinary::getType() const
 {
 	return mType;
 }
 
-void nx::ContentMetaBinary::setType(cnmt::ContentMetaType type)
+void nn::hac::ContentMetaBinary::setType(cnmt::ContentMetaType type)
 {
 	mType = type;
 }
 
-byte_t nx::ContentMetaBinary::getAttributes() const
+byte_t nn::hac::ContentMetaBinary::getAttributes() const
 {
 	return mAttributes;
 }
 
-void nx::ContentMetaBinary::setAttributes(byte_t attributes)
+void nn::hac::ContentMetaBinary::setAttributes(byte_t attributes)
 {
 	mAttributes = attributes;
 }
 
-uint32_t nx::ContentMetaBinary::getRequiredDownloadSystemVersion() const
+uint32_t nn::hac::ContentMetaBinary::getRequiredDownloadSystemVersion() const
 {
 	return mRequiredDownloadSystemVersion;
 }
 
-void nx::ContentMetaBinary::setRequiredDownloadSystemVersion(uint32_t version)
+void nn::hac::ContentMetaBinary::setRequiredDownloadSystemVersion(uint32_t version)
 {
 	mRequiredDownloadSystemVersion = version;
 }
 
-const nx::ContentMetaBinary::ApplicationMetaExtendedHeader& nx::ContentMetaBinary::getApplicationMetaExtendedHeader() const
+const nn::hac::ContentMetaBinary::ApplicationMetaExtendedHeader& nn::hac::ContentMetaBinary::getApplicationMetaExtendedHeader() const
 {
 	return mApplicationMetaExtendedHeader;
 }
 
-void nx::ContentMetaBinary::setApplicationMetaExtendedHeader(const ApplicationMetaExtendedHeader& exhdr)
+void nn::hac::ContentMetaBinary::setApplicationMetaExtendedHeader(const ApplicationMetaExtendedHeader& exhdr)
 {
 	mApplicationMetaExtendedHeader = exhdr;
 }
 
-const nx::ContentMetaBinary::PatchMetaExtendedHeader& nx::ContentMetaBinary::getPatchMetaExtendedHeader() const
+const nn::hac::ContentMetaBinary::PatchMetaExtendedHeader& nn::hac::ContentMetaBinary::getPatchMetaExtendedHeader() const
 {
 	return mPatchMetaExtendedHeader;
 }
 
-void nx::ContentMetaBinary::setPatchMetaExtendedHeader(const PatchMetaExtendedHeader& exhdr)
+void nn::hac::ContentMetaBinary::setPatchMetaExtendedHeader(const PatchMetaExtendedHeader& exhdr)
 {
 	mPatchMetaExtendedHeader = exhdr;
 }
 
-const nx::ContentMetaBinary::AddOnContentMetaExtendedHeader& nx::ContentMetaBinary::getAddOnContentMetaExtendedHeader() const
+const nn::hac::ContentMetaBinary::AddOnContentMetaExtendedHeader& nn::hac::ContentMetaBinary::getAddOnContentMetaExtendedHeader() const
 {
 	return mAddOnContentMetaExtendedHeader;
 }
 
-void nx::ContentMetaBinary::setAddOnContentMetaExtendedHeader(const AddOnContentMetaExtendedHeader& exhdr)
+void nn::hac::ContentMetaBinary::setAddOnContentMetaExtendedHeader(const AddOnContentMetaExtendedHeader& exhdr)
 {
 	mAddOnContentMetaExtendedHeader = exhdr;
 }
 
-const nx::ContentMetaBinary::DeltaMetaExtendedHeader& nx::ContentMetaBinary::getDeltaMetaExtendedHeader() const
+const nn::hac::ContentMetaBinary::DeltaMetaExtendedHeader& nn::hac::ContentMetaBinary::getDeltaMetaExtendedHeader() const
 {
 	return mDeltaMetaExtendedHeader;
 }
 
-void nx::ContentMetaBinary::setDeltaMetaExtendedHeader(const DeltaMetaExtendedHeader& exhdr)
+void nn::hac::ContentMetaBinary::setDeltaMetaExtendedHeader(const DeltaMetaExtendedHeader& exhdr)
 {
 	mDeltaMetaExtendedHeader = exhdr;
 }
 
-const fnd::List<nx::ContentMetaBinary::ContentInfo>& nx::ContentMetaBinary::getContentInfo() const
+const fnd::List<nn::hac::ContentMetaBinary::ContentInfo>& nn::hac::ContentMetaBinary::getContentInfo() const
 {
 	return mContentInfo;
 }
 
-void nx::ContentMetaBinary::setContentInfo(const fnd::List<nx::ContentMetaBinary::ContentInfo>& info)
+void nn::hac::ContentMetaBinary::setContentInfo(const fnd::List<nn::hac::ContentMetaBinary::ContentInfo>& info)
 {
 	mContentInfo = info;
 }
 
-const fnd::List<nx::ContentMetaBinary::ContentMetaInfo>& nx::ContentMetaBinary::getContentMetaInfo() const
+const fnd::List<nn::hac::ContentMetaBinary::ContentMetaInfo>& nn::hac::ContentMetaBinary::getContentMetaInfo() const
 {
 	return mContentMetaInfo;
 }
 
-void nx::ContentMetaBinary::setContentMetaInfo(const fnd::List<nx::ContentMetaBinary::ContentMetaInfo>& info)
+void nn::hac::ContentMetaBinary::setContentMetaInfo(const fnd::List<nn::hac::ContentMetaBinary::ContentMetaInfo>& info)
 {
 	mContentMetaInfo = info;
 }
 
-const fnd::Vec<byte_t> & nx::ContentMetaBinary::getExtendedData() const
+const fnd::Vec<byte_t> & nn::hac::ContentMetaBinary::getExtendedData() const
 {
 	return mExtendedData;
 }
 
-void nx::ContentMetaBinary::setExtendedData(const fnd::Vec<byte_t> & data)
+void nn::hac::ContentMetaBinary::setExtendedData(const fnd::Vec<byte_t> & data)
 {
 	mExtendedData = data;
 }
 
-const nx::sDigest & nx::ContentMetaBinary::getDigest() const
+const nn::hac::sDigest & nn::hac::ContentMetaBinary::getDigest() const
 {
 	return mDigest;
 }
 
-void nx::ContentMetaBinary::setDigest(const nx::sDigest & digest)
+void nn::hac::ContentMetaBinary::setDigest(const nn::hac::sDigest & digest)
 {
 
 	memcpy(mDigest.data, digest.data, cnmt::kDigestLen);
 }
 
-bool nx::ContentMetaBinary::validateExtendedHeaderSize(cnmt::ContentMetaType type, size_t exhdrSize) const
+bool nn::hac::ContentMetaBinary::validateExtendedHeaderSize(cnmt::ContentMetaType type, size_t exhdrSize) const
 {
 	bool validSize = false;
 
@@ -333,7 +333,7 @@ bool nx::ContentMetaBinary::validateExtendedHeaderSize(cnmt::ContentMetaType typ
 	return validSize;
 }
 
-size_t nx::ContentMetaBinary::getExtendedDataSize(cnmt::ContentMetaType type, const byte_t * data) const
+size_t nn::hac::ContentMetaBinary::getExtendedDataSize(cnmt::ContentMetaType type, const byte_t * data) const
 {
 	size_t exdata_len = 0;
 	if (type == cnmt::METATYPE_PATCH)
@@ -349,7 +349,7 @@ size_t nx::ContentMetaBinary::getExtendedDataSize(cnmt::ContentMetaType type, co
 	return exdata_len;
 }
 
-void nx::ContentMetaBinary::validateBinary(const byte_t * data, size_t len) const
+void nn::hac::ContentMetaBinary::validateBinary(const byte_t * data, size_t len) const
 {
 	// check if it is large enough to read the header
 	if (len < sizeof(sContentMetaHeader))

lib/libhac/source/FileSystemAccessControlBinary.cpp

@@ -1,18 +1,18 @@
-#include <nx/FileSystemAccessControlBinary.h>
+#include <nn/hac/FileSystemAccessControlBinary.h>
 
 #include <fnd/SimpleTextOutput.h>
 
-nx::FileSystemAccessControlBinary::FileSystemAccessControlBinary()
+nn::hac::FileSystemAccessControlBinary::FileSystemAccessControlBinary()
 {
 	clear();
 }
 
-nx::FileSystemAccessControlBinary::FileSystemAccessControlBinary(const FileSystemAccessControlBinary & other)
+nn::hac::FileSystemAccessControlBinary::FileSystemAccessControlBinary(const FileSystemAccessControlBinary & other)
 {
 	*this = other;
 }
 
-void nx::FileSystemAccessControlBinary::operator=(const FileSystemAccessControlBinary & other)
+void nn::hac::FileSystemAccessControlBinary::operator=(const FileSystemAccessControlBinary & other)
 {
 	mRawBinary = other.mRawBinary;
 	mVersion = other.mVersion;
@@ -21,7 +21,7 @@ void nx::FileSystemAccessControlBinary::operator=(const FileSystemAccessControlB
 	mSaveDataOwnerIdList = other.mSaveDataOwnerIdList;
 }
 
-bool nx::FileSystemAccessControlBinary::operator==(const FileSystemAccessControlBinary & other) const
+bool nn::hac::FileSystemAccessControlBinary::operator==(const FileSystemAccessControlBinary & other) const
 {
 	return (mVersion == other.mVersion) \
 		&& (mFsaRights == other.mFsaRights) \
@@ -29,12 +29,12 @@ bool nx::FileSystemAccessControlBinary::operator==(const FileSystemAccessControl
 		&& (mSaveDataOwnerIdList == other.mSaveDataOwnerIdList);
 }
 
-bool nx::FileSystemAccessControlBinary::operator!=(const FileSystemAccessControlBinary & other) const
+bool nn::hac::FileSystemAccessControlBinary::operator!=(const FileSystemAccessControlBinary & other) const
 {
 	return !(*this == other);
 }
 
-void nx::FileSystemAccessControlBinary::toBytes()
+void nn::hac::FileSystemAccessControlBinary::toBytes()
 {
 	// determine section layout
 	struct sLayout {
@@ -91,7 +91,7 @@ void nx::FileSystemAccessControlBinary::toBytes()
 	}
 }
 
-void nx::FileSystemAccessControlBinary::fromBytes(const byte_t* data, size_t len)
+void nn::hac::FileSystemAccessControlBinary::fromBytes(const byte_t* data, size_t len)
 {
 	// check size
 	if (len < sizeof(sFacHeader))
@@ -157,12 +157,12 @@ void nx::FileSystemAccessControlBinary::fromBytes(const byte_t* data, size_t len
 	}
 }
 
-const fnd::Vec<byte_t>& nx::FileSystemAccessControlBinary::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::FileSystemAccessControlBinary::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::FileSystemAccessControlBinary::clear()
+void nn::hac::FileSystemAccessControlBinary::clear()
 {
 	mRawBinary.clear();
 	mVersion = 0;
@@ -171,42 +171,42 @@ void nx::FileSystemAccessControlBinary::clear()
 	mSaveDataOwnerIdList.clear();
 }
 
-uint32_t nx::FileSystemAccessControlBinary::getFormatVersion() const
+uint32_t nn::hac::FileSystemAccessControlBinary::getFormatVersion() const
 {
 	return mVersion;
 }
 
-void nx::FileSystemAccessControlBinary::setFormatVersion(uint32_t format_version)
+void nn::hac::FileSystemAccessControlBinary::setFormatVersion(uint32_t format_version)
 {
 	mVersion = format_version;
 }
 
-const fnd::List<nx::fac::FsAccessFlag>& nx::FileSystemAccessControlBinary::getFsaRightsList() const
+const fnd::List<nn::hac::fac::FsAccessFlag>& nn::hac::FileSystemAccessControlBinary::getFsaRightsList() const
 {
 	return mFsaRights;
 }
 
-void nx::FileSystemAccessControlBinary::setFsaRightsList(const fnd::List<fac::FsAccessFlag>& list)
+void nn::hac::FileSystemAccessControlBinary::setFsaRightsList(const fnd::List<fac::FsAccessFlag>& list)
 {
 	mFsaRights = list;
 }
 
-const fnd::List<uint64_t>& nx::FileSystemAccessControlBinary::getContentOwnerIdList() const
+const fnd::List<uint64_t>& nn::hac::FileSystemAccessControlBinary::getContentOwnerIdList() const
 {
 	return mContentOwnerIdList;
 }
 
-void nx::FileSystemAccessControlBinary::setContentOwnerIdList(const fnd::List<uint64_t>& list)
+void nn::hac::FileSystemAccessControlBinary::setContentOwnerIdList(const fnd::List<uint64_t>& list)
 {
 	mContentOwnerIdList = list;
 }
 
-const fnd::List<nx::FileSystemAccessControlBinary::sSaveDataOwnerId>& nx::FileSystemAccessControlBinary::getSaveDataOwnerIdList() const
+const fnd::List<nn::hac::FileSystemAccessControlBinary::sSaveDataOwnerId>& nn::hac::FileSystemAccessControlBinary::getSaveDataOwnerIdList() const
 {
 	return mSaveDataOwnerIdList;
 }
 
-void nx::FileSystemAccessControlBinary::setSaveDataOwnerIdList(const fnd::List<sSaveDataOwnerId>& list)
+void nn::hac::FileSystemAccessControlBinary::setSaveDataOwnerIdList(const fnd::List<sSaveDataOwnerId>& list)
 {
 	mSaveDataOwnerIdList = list;
 }

lib/libhac/source/HandleTableSizeEntry.cpp

@@ -1,47 +1,47 @@
-#include <nx/HandleTableSizeEntry.h>
+#include <nn/hac/HandleTableSizeEntry.h>
 
-nx::HandleTableSizeEntry::HandleTableSizeEntry() :
+nn::hac::HandleTableSizeEntry::HandleTableSizeEntry() :
 	mCap(kCapId),
 	mHandleTableSize(0)
 {}
 
-nx::HandleTableSizeEntry::HandleTableSizeEntry(const KernelCapabilityEntry & kernel_cap) :
+nn::hac::HandleTableSizeEntry::HandleTableSizeEntry(const KernelCapabilityEntry & kernel_cap) :
 	mCap(kCapId),
 	mHandleTableSize(0)
 {
 	setKernelCapability(kernel_cap);
 }
 
-nx::HandleTableSizeEntry::HandleTableSizeEntry(uint16_t size) :
+nn::hac::HandleTableSizeEntry::HandleTableSizeEntry(uint16_t size) :
 	mCap(kCapId),
 	mHandleTableSize(0)
 {
 	setHandleTableSize(size);
 }
 
-void nx::HandleTableSizeEntry::operator=(const HandleTableSizeEntry& other)
+void nn::hac::HandleTableSizeEntry::operator=(const HandleTableSizeEntry& other)
 {
 	mHandleTableSize = other.mHandleTableSize;
 	updateCapField();
 }
 
-bool nx::HandleTableSizeEntry::operator==(const HandleTableSizeEntry& other) const
+bool nn::hac::HandleTableSizeEntry::operator==(const HandleTableSizeEntry& other) const
 {
 	return (mHandleTableSize == other.mHandleTableSize);
 }
 
-bool nx::HandleTableSizeEntry::operator!=(const HandleTableSizeEntry& other) const
+bool nn::hac::HandleTableSizeEntry::operator!=(const HandleTableSizeEntry& other) const
 {
 	return !(*this == other);
 }
 
 
-const nx::KernelCapabilityEntry & nx::HandleTableSizeEntry::getKernelCapability() const
+const nn::hac::KernelCapabilityEntry & nn::hac::HandleTableSizeEntry::getKernelCapability() const
 {
 	return mCap;
 }
 
-void nx::HandleTableSizeEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
+void nn::hac::HandleTableSizeEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
 {
 	if (kernel_cap.getType() != kCapId)
 	{
@@ -52,12 +52,12 @@ void nx::HandleTableSizeEntry::setKernelCapability(const KernelCapabilityEntry &
 	processCapField();
 }
 
-uint16_t nx::HandleTableSizeEntry::getHandleTableSize() const
+uint16_t nn::hac::HandleTableSizeEntry::getHandleTableSize() const
 {
 	return mHandleTableSize;
 }
 
-void nx::HandleTableSizeEntry::setHandleTableSize(uint16_t size)
+void nn::hac::HandleTableSizeEntry::setHandleTableSize(uint16_t size)
 {
 	if (size > kMaxHandleTableSize)
 	{

lib/libhac/source/HandleTableSizeHandler.cpp

@@ -1,28 +1,28 @@
-#include <nx/HandleTableSizeHandler.h>
+#include <nn/hac/HandleTableSizeHandler.h>
 
-nx::HandleTableSizeHandler::HandleTableSizeHandler() :
+nn::hac::HandleTableSizeHandler::HandleTableSizeHandler() :
 	mIsSet(false),
 	mEntry(0)
 {}
 
-void nx::HandleTableSizeHandler::operator=(const HandleTableSizeHandler & other)
+void nn::hac::HandleTableSizeHandler::operator=(const HandleTableSizeHandler & other)
 {
 	mIsSet = other.mIsSet;
 	mEntry.setKernelCapability(other.mEntry.getKernelCapability());
 }
 
-bool nx::HandleTableSizeHandler::operator==(const HandleTableSizeHandler & other) const
+bool nn::hac::HandleTableSizeHandler::operator==(const HandleTableSizeHandler & other) const
 {
 	return (mIsSet == other.mIsSet) \
 		&& (mEntry.getKernelCapability() == other.mEntry.getKernelCapability());
 }
 
-bool nx::HandleTableSizeHandler::operator!=(const HandleTableSizeHandler & other) const
+bool nn::hac::HandleTableSizeHandler::operator!=(const HandleTableSizeHandler & other) const
 {
 	return !(*this == other);
 }
 
-void nx::HandleTableSizeHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
+void nn::hac::HandleTableSizeHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
 {
 	if (caps.size() > kMaxKernelCapNum)
 	{
@@ -36,7 +36,7 @@ void nx::HandleTableSizeHandler::importKernelCapabilityList(const fnd::List<Kern
 	mIsSet = true;
 }
 
-void nx::HandleTableSizeHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
+void nn::hac::HandleTableSizeHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
 {
 	if (isSet() == false)
 		return;
@@ -44,23 +44,23 @@ void nx::HandleTableSizeHandler::exportKernelCapabilityList(fnd::List<KernelCapa
 	caps.addElement(mEntry.getKernelCapability());
 }
 
-void nx::HandleTableSizeHandler::clear()
+void nn::hac::HandleTableSizeHandler::clear()
 {
 	mIsSet = false;
 	mEntry.setHandleTableSize(0);
 }
 
-bool nx::HandleTableSizeHandler::isSet() const
+bool nn::hac::HandleTableSizeHandler::isSet() const
 {
 	return mIsSet;
 }
 
-uint16_t nx::HandleTableSizeHandler::getHandleTableSize() const
+uint16_t nn::hac::HandleTableSizeHandler::getHandleTableSize() const
 {
 	return mEntry.getHandleTableSize();
 }
 
-void nx::HandleTableSizeHandler::setHandleTableSize(uint16_t size)
+void nn::hac::HandleTableSizeHandler::setHandleTableSize(uint16_t size)
 {
 	mEntry.setHandleTableSize(size);
 	mIsSet = true;

lib/libhac/source/HierarchicalIntegrityHeader.cpp

@@ -1,17 +1,17 @@
 #include <sstream>
-#include <nx/HierarchicalIntegrityHeader.h>
+#include <nn/hac/HierarchicalIntegrityHeader.h>
 
-nx::HierarchicalIntegrityHeader::HierarchicalIntegrityHeader()
+nn::hac::HierarchicalIntegrityHeader::HierarchicalIntegrityHeader()
 {
 	clear();
 }
 
-nx::HierarchicalIntegrityHeader::HierarchicalIntegrityHeader(const HierarchicalIntegrityHeader & other)
+nn::hac::HierarchicalIntegrityHeader::HierarchicalIntegrityHeader(const HierarchicalIntegrityHeader & other)
 {
 	*this = other;
 }
 
-void nx::HierarchicalIntegrityHeader::operator=(const HierarchicalIntegrityHeader & other)
+void nn::hac::HierarchicalIntegrityHeader::operator=(const HierarchicalIntegrityHeader & other)
 {
 	if (other.getBytes().size() != 0)
 	{
@@ -25,33 +25,33 @@ void nx::HierarchicalIntegrityHeader::operator=(const HierarchicalIntegrityHeade
 	}
 }
 
-bool nx::HierarchicalIntegrityHeader::operator==(const HierarchicalIntegrityHeader & other) const
+bool nn::hac::HierarchicalIntegrityHeader::operator==(const HierarchicalIntegrityHeader & other) const
 {
 	return (mLayerInfo == other.mLayerInfo) \
 		&& (mMasterHashList == other.mMasterHashList);
 }
 
-bool nx::HierarchicalIntegrityHeader::operator!=(const HierarchicalIntegrityHeader & other) const
+bool nn::hac::HierarchicalIntegrityHeader::operator!=(const HierarchicalIntegrityHeader & other) const
 {
 	return !(*this == other);
 }
 
-void nx::HierarchicalIntegrityHeader::toBytes()
+void nn::hac::HierarchicalIntegrityHeader::toBytes()
 {
 	throw fnd::Exception(kModuleName, "exportBinary() not implemented");
 }
 
-void nx::HierarchicalIntegrityHeader::fromBytes(const byte_t* data, size_t len)
+void nn::hac::HierarchicalIntegrityHeader::fromBytes(const byte_t* data, size_t len)
 {
 	std::stringstream error_str;
 
 	// validate size for at least header
-	if (len < sizeof(nx::sHierarchicalIntegrityHeader))
+	if (len < sizeof(nn::hac::sHierarchicalIntegrityHeader))
 	{
 		throw fnd::Exception(kModuleName, "Header too small");
 	}
 
-	const nx::sHierarchicalIntegrityHeader* hdr = (const nx::sHierarchicalIntegrityHeader*)data;
+	const nn::hac::sHierarchicalIntegrityHeader* hdr = (const nn::hac::sHierarchicalIntegrityHeader*)data;
 
 	// Validate Header Sig "IVFC"
 	if (hdr->st_magic.get() != hierarchicalintegrity::kStructMagic)
@@ -60,7 +60,7 @@ void nx::HierarchicalIntegrityHeader::fromBytes(const byte_t* data, size_t len)
 	}
 
 	// Validate TypeId
-	if (hdr->type_id.get() != nx::hierarchicalintegrity::kRomfsTypeId)
+	if (hdr->type_id.get() != nn::hac::hierarchicalintegrity::kRomfsTypeId)
 	{
 		error_str.clear();
 		error_str << "Unsupported type id (" << std::hex << hdr->type_id.get() << ")";
@@ -72,12 +72,12 @@ void nx::HierarchicalIntegrityHeader::fromBytes(const byte_t* data, size_t len)
 	{
 		error_str.clear();
 		error_str << "Invalid layer count. ";
-		error_str << "(actual=" << std::dec << hdr->layer_num.get() << ", expected=" << nx::hierarchicalintegrity::kDefaultLayerNum+1 << ")";
+		error_str << "(actual=" << std::dec << hdr->layer_num.get() << ", expected=" << nn::hac::hierarchicalintegrity::kDefaultLayerNum+1 << ")";
 		throw fnd::Exception(kModuleName, error_str.str());
 	}
 	
 	// Get Sizes/Offsets
-	size_t master_hash_offset = align((sizeof(nx::sHierarchicalIntegrityHeader) + sizeof(nx::sHierarchicalIntegrityLayerInfo) * hdr->layer_num.get()), nx::hierarchicalintegrity::kHeaderAlignLen);
+	size_t master_hash_offset = align((sizeof(nn::hac::sHierarchicalIntegrityHeader) + sizeof(nn::hac::sHierarchicalIntegrityLayerInfo) * hdr->layer_num.get()), nn::hac::hierarchicalintegrity::kHeaderAlignLen);
 	size_t total_size = master_hash_offset + hdr->master_hash_size.get();
 
 	// Validate total size
@@ -91,7 +91,7 @@ void nx::HierarchicalIntegrityHeader::fromBytes(const byte_t* data, size_t len)
 	memcpy(mRawBinary.data(), data, mRawBinary.size());
 
 	// save layer info
-	const nx::sHierarchicalIntegrityLayerInfo* layer_info = (const nx::sHierarchicalIntegrityLayerInfo*)(mRawBinary.data() + sizeof(nx::sHierarchicalIntegrityHeader));
+	const nn::hac::sHierarchicalIntegrityLayerInfo* layer_info = (const nn::hac::sHierarchicalIntegrityLayerInfo*)(mRawBinary.data() + sizeof(nn::hac::sHierarchicalIntegrityHeader));
 	for (size_t i = 0; i < hierarchicalintegrity::kDefaultLayerNum; i++)
 	{
 		mLayerInfo.addElement({layer_info[i].offset.get(), layer_info[i].size.get(), layer_info[i].block_size.get()});
@@ -105,33 +105,33 @@ void nx::HierarchicalIntegrityHeader::fromBytes(const byte_t* data, size_t len)
 	}
 }
 
-const fnd::Vec<byte_t>& nx::HierarchicalIntegrityHeader::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::HierarchicalIntegrityHeader::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::HierarchicalIntegrityHeader::clear()
+void nn::hac::HierarchicalIntegrityHeader::clear()
 {
 	mLayerInfo.clear();
 	mMasterHashList.clear();
 }
 
-const fnd::List<nx::HierarchicalIntegrityHeader::sLayer>& nx::HierarchicalIntegrityHeader::getLayerInfo() const
+const fnd::List<nn::hac::HierarchicalIntegrityHeader::sLayer>& nn::hac::HierarchicalIntegrityHeader::getLayerInfo() const
 {
 	return mLayerInfo;
 }
 
-void nx::HierarchicalIntegrityHeader::setLayerInfo(const fnd::List<sLayer>& layer_info)
+void nn::hac::HierarchicalIntegrityHeader::setLayerInfo(const fnd::List<sLayer>& layer_info)
 {
 	mLayerInfo = layer_info;
 }
 
-const fnd::List<crypto::sha::sSha256Hash>& nx::HierarchicalIntegrityHeader::getMasterHashList() const
+const fnd::List<crypto::sha::sSha256Hash>& nn::hac::HierarchicalIntegrityHeader::getMasterHashList() const
 {
 	return mMasterHashList;
 }
 
-void nx::HierarchicalIntegrityHeader::setMasterHashList(const fnd::List<crypto::sha::sSha256Hash>& master_hash_list)
+void nn::hac::HierarchicalIntegrityHeader::setMasterHashList(const fnd::List<crypto::sha::sSha256Hash>& master_hash_list)
 {
 	mMasterHashList = master_hash_list;
 }

lib/libhac/source/HierarchicalSha256Header.cpp

@@ -1,17 +1,17 @@
 #include <sstream>
-#include <nx/HierarchicalSha256Header.h>
+#include <nn/hac/HierarchicalSha256Header.h>
 
-nx::HierarchicalSha256Header::HierarchicalSha256Header()
+nn::hac::HierarchicalSha256Header::HierarchicalSha256Header()
 {
 	clear();
 }
 
-nx::HierarchicalSha256Header::HierarchicalSha256Header(const HierarchicalSha256Header & other)
+nn::hac::HierarchicalSha256Header::HierarchicalSha256Header(const HierarchicalSha256Header & other)
 {
 	*this = other;
 }
 
-void nx::HierarchicalSha256Header::operator=(const HierarchicalSha256Header & other)
+void nn::hac::HierarchicalSha256Header::operator=(const HierarchicalSha256Header & other)
 {
 	if (other.getBytes().size() != 0)
 	{
@@ -25,39 +25,39 @@ void nx::HierarchicalSha256Header::operator=(const HierarchicalSha256Header & ot
 	}
 }
 
-bool nx::HierarchicalSha256Header::operator==(const HierarchicalSha256Header & other) const
+bool nn::hac::HierarchicalSha256Header::operator==(const HierarchicalSha256Header & other) const
 {
 	return (mMasterHash == other.mMasterHash) \
 		&& (mHashBlockSize == other.mHashBlockSize) \
 		&& (mLayerInfo == other.mLayerInfo);
 }
 
-bool nx::HierarchicalSha256Header::operator!=(const HierarchicalSha256Header & other) const
+bool nn::hac::HierarchicalSha256Header::operator!=(const HierarchicalSha256Header & other) const
 {
 	return !(*this == other);
 }
 
-void nx::HierarchicalSha256Header::toBytes()
+void nn::hac::HierarchicalSha256Header::toBytes()
 {
 	throw fnd::Exception(kModuleName, "exportBinary() not implemented");
 }
 
-void nx::HierarchicalSha256Header::fromBytes(const byte_t* data, size_t len)
+void nn::hac::HierarchicalSha256Header::fromBytes(const byte_t* data, size_t len)
 {
 	std::stringstream error_str;
 
-	if (len < sizeof(nx::sHierarchicalSha256Header))
+	if (len < sizeof(nn::hac::sHierarchicalSha256Header))
 	{
 		throw fnd::Exception(kModuleName, "Header too small");
 	}
 
-	const nx::sHierarchicalSha256Header* hdr = (const nx::sHierarchicalSha256Header*)data;
+	const nn::hac::sHierarchicalSha256Header* hdr = (const nn::hac::sHierarchicalSha256Header*)data;
 
-	if (hdr->layer_num.get() != nx::hierarchicalsha256::kDefaultLayerNum)
+	if (hdr->layer_num.get() != nn::hac::hierarchicalsha256::kDefaultLayerNum)
 	{
 		error_str.clear();
 		error_str << "Invalid layer count. ";
-		error_str << "(actual=" << std::dec << hdr->layer_num.get() << ", expected=" << nx::hierarchicalsha256::kDefaultLayerNum << ")";
+		error_str << "(actual=" << std::dec << hdr->layer_num.get() << ", expected=" << nn::hac::hierarchicalsha256::kDefaultLayerNum << ")";
 		throw fnd::Exception(kModuleName, error_str.str());
 	}
 
@@ -69,44 +69,44 @@ void nx::HierarchicalSha256Header::fromBytes(const byte_t* data, size_t len)
 	}
 }
 
-const fnd::Vec<byte_t>& nx::HierarchicalSha256Header::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::HierarchicalSha256Header::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::HierarchicalSha256Header::clear()
+void nn::hac::HierarchicalSha256Header::clear()
 {
 	memset(mMasterHash.bytes, 0, sizeof(crypto::sha::sSha256Hash));
 	mHashBlockSize = 0;
 	mLayerInfo.clear();
 }
 
-const crypto::sha::sSha256Hash & nx::HierarchicalSha256Header::getMasterHash() const
+const crypto::sha::sSha256Hash & nn::hac::HierarchicalSha256Header::getMasterHash() const
 {
 	return mMasterHash;
 }
 
-void nx::HierarchicalSha256Header::setMasterHash(const crypto::sha::sSha256Hash & master_hash)
+void nn::hac::HierarchicalSha256Header::setMasterHash(const crypto::sha::sSha256Hash & master_hash)
 {
 	mMasterHash = master_hash;
 }
 
-size_t nx::HierarchicalSha256Header::getHashBlockSize() const
+size_t nn::hac::HierarchicalSha256Header::getHashBlockSize() const
 {
 	return mHashBlockSize;
 }
 
-void nx::HierarchicalSha256Header::setHashBlockSize(size_t hash_block_size)
+void nn::hac::HierarchicalSha256Header::setHashBlockSize(size_t hash_block_size)
 {
 	mHashBlockSize = hash_block_size;
 }
 
-const fnd::List<nx::HierarchicalSha256Header::sLayer>& nx::HierarchicalSha256Header::getLayerInfo() const
+const fnd::List<nn::hac::HierarchicalSha256Header::sLayer>& nn::hac::HierarchicalSha256Header::getLayerInfo() const
 {
 	return mLayerInfo;
 }
 
-void nx::HierarchicalSha256Header::setLayerInfo(const fnd::List<sLayer>& layer_info)
+void nn::hac::HierarchicalSha256Header::setLayerInfo(const fnd::List<sLayer>& layer_info)
 {
 	mLayerInfo = layer_info;
 }

lib/libhac/source/InteruptEntry.cpp

@@ -1,20 +1,20 @@
-#include <nx/InteruptEntry.h>
+#include <nn/hac/InteruptEntry.h>
 
-nx::InteruptEntry::InteruptEntry() :
+nn::hac::InteruptEntry::InteruptEntry() :
 	mCap(kCapId),
 	mInterupt{0,0}
 {
 	
 }
 
-nx::InteruptEntry::InteruptEntry(const KernelCapabilityEntry & kernel_cap) :
+nn::hac::InteruptEntry::InteruptEntry(const KernelCapabilityEntry & kernel_cap) :
 	mCap(kCapId),
 	mInterupt{ 0,0 }
 {
 	setKernelCapability(kernel_cap);
 }
 
-nx::InteruptEntry::InteruptEntry(uint32_t interupt0, uint32_t interupt1) :
+nn::hac::InteruptEntry::InteruptEntry(uint32_t interupt0, uint32_t interupt1) :
 	mCap(kCapId),
 	mInterupt{ 0,0 }
 {
@@ -22,30 +22,30 @@ nx::InteruptEntry::InteruptEntry(uint32_t interupt0, uint32_t interupt1) :
 	setInterupt(1, interupt1);
 }
 
-void nx::InteruptEntry::operator=(const InteruptEntry& other)
+void nn::hac::InteruptEntry::operator=(const InteruptEntry& other)
 {
 	mInterupt[0] = other.mInterupt[0];
 	mInterupt[1] = other.mInterupt[1];
 	updateCapField();
 }
 
-bool nx::InteruptEntry::operator==(const InteruptEntry& other) const
+bool nn::hac::InteruptEntry::operator==(const InteruptEntry& other) const
 {
 	return (mInterupt[0] == other.mInterupt[0]) \
 		&& (mInterupt[1] == other.mInterupt[1]);
 }
 
-bool nx::InteruptEntry::operator!=(const InteruptEntry& other) const
+bool nn::hac::InteruptEntry::operator!=(const InteruptEntry& other) const
 {
 	return !(*this == other);
 }
 
-const nx::KernelCapabilityEntry & nx::InteruptEntry::getKernelCapability() const
+const nn::hac::KernelCapabilityEntry & nn::hac::InteruptEntry::getKernelCapability() const
 {
 	return mCap;
 }
 
-void nx::InteruptEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
+void nn::hac::InteruptEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
 {
 	if (kernel_cap.getType() != kCapId)
 	{
@@ -56,17 +56,17 @@ void nx::InteruptEntry::setKernelCapability(const KernelCapabilityEntry & kernel
 	processCapField();
 }
 
-uint32_t nx::InteruptEntry::operator[](size_t index) const
+uint32_t nn::hac::InteruptEntry::operator[](size_t index) const
 {
 	return getInterupt(index);
 }
 
-uint32_t nx::InteruptEntry::getInterupt(size_t index) const
+uint32_t nn::hac::InteruptEntry::getInterupt(size_t index) const
 {
 	return mInterupt[index % kInteruptNum];
 }
 
-void nx::InteruptEntry::setInterupt(size_t index, uint32_t interupt)
+void nn::hac::InteruptEntry::setInterupt(size_t index, uint32_t interupt)
 {
 	if (interupt > kInteruptMax)
 	{

lib/libhac/source/InteruptHandler.cpp

@@ -1,28 +1,28 @@
-#include <nx/InteruptHandler.h>
+#include <nn/hac/InteruptHandler.h>
 
-nx::InteruptHandler::InteruptHandler() :
+nn::hac::InteruptHandler::InteruptHandler() :
 	mIsSet(false),
 	mInterupts()
 {}
 
-void nx::InteruptHandler::operator=(const InteruptHandler & other)
+void nn::hac::InteruptHandler::operator=(const InteruptHandler & other)
 {
 	mIsSet = other.mIsSet;
 	mInterupts = other.mInterupts;
 }
 
-bool nx::InteruptHandler::operator==(const InteruptHandler & other) const
+bool nn::hac::InteruptHandler::operator==(const InteruptHandler & other) const
 {
 	return (mIsSet == other.mIsSet) \
 		&& (mInterupts == other.mInterupts);
 }
 
-bool nx::InteruptHandler::operator!=(const InteruptHandler & other) const
+bool nn::hac::InteruptHandler::operator!=(const InteruptHandler & other) const
 {
 	return !(*this == other);
 }
 
-void nx::InteruptHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
+void nn::hac::InteruptHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
 {
 	if (caps.size() == 0)
 		return;
@@ -58,7 +58,7 @@ void nx::InteruptHandler::importKernelCapabilityList(const fnd::List<KernelCapab
 	mIsSet = true;
 }
 
-void nx::InteruptHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
+void nn::hac::InteruptHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
 {
 	if (isSet() == false)
 		return;
@@ -84,23 +84,23 @@ void nx::InteruptHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityE
 	}
 }
 
-void nx::InteruptHandler::clear()
+void nn::hac::InteruptHandler::clear()
 {
 	mIsSet = false;
 	mInterupts.clear();
 }
 
-bool nx::InteruptHandler::isSet() const
+bool nn::hac::InteruptHandler::isSet() const
 {
 	return mIsSet;
 }
 
-const fnd::List<uint16_t>& nx::InteruptHandler::getInteruptList() const
+const fnd::List<uint16_t>& nn::hac::InteruptHandler::getInteruptList() const
 {
 	return mInterupts;
 }
 
-void nx::InteruptHandler::setInteruptList(const fnd::List<uint16_t>& interupts)
+void nn::hac::InteruptHandler::setInteruptList(const fnd::List<uint16_t>& interupts)
 {
 	mInterupts.clear();
 	for (size_t i = 0; i < interupts.size(); i++)

lib/libhac/source/KernelCapabilityBinary.cpp

@@ -1,14 +1,14 @@
-#include <nx/KernelCapabilityBinary.h>
+#include <nn/hac/KernelCapabilityBinary.h>
 
-nx::KernelCapabilityBinary::KernelCapabilityBinary()
+nn::hac::KernelCapabilityBinary::KernelCapabilityBinary()
 {}
 
-nx::KernelCapabilityBinary::KernelCapabilityBinary(const KernelCapabilityBinary & other)
+nn::hac::KernelCapabilityBinary::KernelCapabilityBinary(const KernelCapabilityBinary & other)
 {
 	*this = other;
 }
 
-void nx::KernelCapabilityBinary::operator=(const KernelCapabilityBinary & other)
+void nn::hac::KernelCapabilityBinary::operator=(const KernelCapabilityBinary & other)
 {
 	clear();
 	mThreadInfo = other.mThreadInfo;
@@ -21,7 +21,7 @@ void nx::KernelCapabilityBinary::operator=(const KernelCapabilityBinary & other)
 	mMiscFlags = other.mMiscFlags;
 }
 
-bool nx::KernelCapabilityBinary::operator==(const KernelCapabilityBinary & other) const
+bool nn::hac::KernelCapabilityBinary::operator==(const KernelCapabilityBinary & other) const
 {
 	return (mThreadInfo == other.mThreadInfo) \
 		&& (mSystemCalls == other.mSystemCalls) \
@@ -33,12 +33,12 @@ bool nx::KernelCapabilityBinary::operator==(const KernelCapabilityBinary & other
 		&& (mMiscFlags == other.mMiscFlags);
 }
 
-bool nx::KernelCapabilityBinary::operator!=(const KernelCapabilityBinary & other) const
+bool nn::hac::KernelCapabilityBinary::operator!=(const KernelCapabilityBinary & other) const
 {
 	return !(*this == other);
 }
 
-void nx::KernelCapabilityBinary::toBytes()
+void nn::hac::KernelCapabilityBinary::toBytes()
 {
 	fnd::List<KernelCapabilityEntry> caps;
 
@@ -63,7 +63,7 @@ void nx::KernelCapabilityBinary::toBytes()
 	}
 }
 
-void nx::KernelCapabilityBinary::fromBytes(const byte_t * data, size_t len)
+void nn::hac::KernelCapabilityBinary::fromBytes(const byte_t * data, size_t len)
 {
 	if ((len % sizeof(uint32_t)) != 0)
 	{
@@ -131,12 +131,12 @@ void nx::KernelCapabilityBinary::fromBytes(const byte_t * data, size_t len)
 	mMiscFlags.importKernelCapabilityList(miscFlagsCaps);
 }
 
-const fnd::Vec<byte_t>& nx::KernelCapabilityBinary::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::KernelCapabilityBinary::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::KernelCapabilityBinary::clear()
+void nn::hac::KernelCapabilityBinary::clear()
 {
 	mRawBinary.clear();
 	mThreadInfo.clear();
@@ -149,82 +149,82 @@ void nx::KernelCapabilityBinary::clear()
 	mMiscFlags.clear();
 }
 
-const nx::ThreadInfoHandler & nx::KernelCapabilityBinary::getThreadInfo() const
+const nn::hac::ThreadInfoHandler & nn::hac::KernelCapabilityBinary::getThreadInfo() const
 {
 	return mThreadInfo;
 }
 
-nx::ThreadInfoHandler & nx::KernelCapabilityBinary::getThreadInfo()
+nn::hac::ThreadInfoHandler & nn::hac::KernelCapabilityBinary::getThreadInfo()
 {
 	return mThreadInfo;
 }
 
-const nx::SystemCallHandler & nx::KernelCapabilityBinary::getSystemCalls() const
+const nn::hac::SystemCallHandler & nn::hac::KernelCapabilityBinary::getSystemCalls() const
 {
 	return mSystemCalls;
 }
 
-nx::SystemCallHandler & nx::KernelCapabilityBinary::getSystemCalls()
+nn::hac::SystemCallHandler & nn::hac::KernelCapabilityBinary::getSystemCalls()
 {
 	return mSystemCalls;
 }
 
-const nx::MemoryMappingHandler & nx::KernelCapabilityBinary::getMemoryMaps() const
+const nn::hac::MemoryMappingHandler & nn::hac::KernelCapabilityBinary::getMemoryMaps() const
 {
 	return mMemoryMap;
 }
 
-nx::MemoryMappingHandler & nx::KernelCapabilityBinary::getMemoryMaps()
+nn::hac::MemoryMappingHandler & nn::hac::KernelCapabilityBinary::getMemoryMaps()
 {
 	return mMemoryMap;
 }
 
-const nx::InteruptHandler & nx::KernelCapabilityBinary::getInterupts() const
+const nn::hac::InteruptHandler & nn::hac::KernelCapabilityBinary::getInterupts() const
 {
 	return mInterupts;
 }
 
-nx::InteruptHandler & nx::KernelCapabilityBinary::getInterupts()
+nn::hac::InteruptHandler & nn::hac::KernelCapabilityBinary::getInterupts()
 {
 	return mInterupts;
 }
 
-const nx::MiscParamsHandler & nx::KernelCapabilityBinary::getMiscParams() const
+const nn::hac::MiscParamsHandler & nn::hac::KernelCapabilityBinary::getMiscParams() const
 {
 	return mMiscParams;
 }
 
-nx::MiscParamsHandler & nx::KernelCapabilityBinary::getMiscParams()
+nn::hac::MiscParamsHandler & nn::hac::KernelCapabilityBinary::getMiscParams()
 {
 	return mMiscParams;
 }
 
-const nx::KernelVersionHandler & nx::KernelCapabilityBinary::getKernelVersion() const
+const nn::hac::KernelVersionHandler & nn::hac::KernelCapabilityBinary::getKernelVersion() const
 {
 	return mKernelVersion;
 }
 
-nx::KernelVersionHandler & nx::KernelCapabilityBinary::getKernelVersion()
+nn::hac::KernelVersionHandler & nn::hac::KernelCapabilityBinary::getKernelVersion()
 {
 	return mKernelVersion;
 }
 
-const nx::HandleTableSizeHandler & nx::KernelCapabilityBinary::getHandleTableSize() const
+const nn::hac::HandleTableSizeHandler & nn::hac::KernelCapabilityBinary::getHandleTableSize() const
 {
 	return mHandleTableSize;
 }
 
-nx::HandleTableSizeHandler & nx::KernelCapabilityBinary::getHandleTableSize()
+nn::hac::HandleTableSizeHandler & nn::hac::KernelCapabilityBinary::getHandleTableSize()
 {
 	return mHandleTableSize;
 }
 
-const nx::MiscFlagsHandler & nx::KernelCapabilityBinary::getMiscFlags() const
+const nn::hac::MiscFlagsHandler & nn::hac::KernelCapabilityBinary::getMiscFlags() const
 {
 	return mMiscFlags;
 }
 
-nx::MiscFlagsHandler & nx::KernelCapabilityBinary::getMiscFlags()
+nn::hac::MiscFlagsHandler & nn::hac::KernelCapabilityBinary::getMiscFlags()
 {
 	return mMiscFlags;
 }

lib/libhac/source/KernelCapabilityEntry.cpp

@@ -1,63 +1,63 @@
-#include <nx/KernelCapabilityEntry.h>
+#include <nn/hac/KernelCapabilityEntry.h>
 
-nx::KernelCapabilityEntry::KernelCapabilityEntry() :
+nn::hac::KernelCapabilityEntry::KernelCapabilityEntry() :
 	mType(kc::KC_INVALID)
 {}
 
-nx::KernelCapabilityEntry::KernelCapabilityEntry(kc::KernelCapId type) :
+nn::hac::KernelCapabilityEntry::KernelCapabilityEntry(kc::KernelCapId type) :
 	mType(type),
 	mField(0)
 {}
 
-nx::KernelCapabilityEntry::KernelCapabilityEntry(kc::KernelCapId type, uint32_t field) :
+nn::hac::KernelCapabilityEntry::KernelCapabilityEntry(kc::KernelCapId type, uint32_t field) :
 	mType(type),
 	mField(field)
 {}
 
-void nx::KernelCapabilityEntry::operator=(const KernelCapabilityEntry & other)
+void nn::hac::KernelCapabilityEntry::operator=(const KernelCapabilityEntry & other)
 {
 	mType = other.mType;
 	mField = other.mField;
 }
 
-bool nx::KernelCapabilityEntry::operator==(const KernelCapabilityEntry & other) const
+bool nn::hac::KernelCapabilityEntry::operator==(const KernelCapabilityEntry & other) const
 {
 	return (mType == other.mType) \
 		&& (mField == other.mField);
 }
 
-bool nx::KernelCapabilityEntry::operator!=(const KernelCapabilityEntry & other) const
+bool nn::hac::KernelCapabilityEntry::operator!=(const KernelCapabilityEntry & other) const
 {
 	return !operator==(other);
 }
 
-uint32_t nx::KernelCapabilityEntry::getCap() const
+uint32_t nn::hac::KernelCapabilityEntry::getCap() const
 {
 	return (mField & getFieldMask()) << getFieldShift() | getCapMask();
 }
 
-void nx::KernelCapabilityEntry::setCap(uint32_t cap)
+void nn::hac::KernelCapabilityEntry::setCap(uint32_t cap)
 {
 	mType = getCapId(cap);
 	mField = (cap >> getFieldShift()) & getFieldMask();
 }
 
-nx::kc::KernelCapId nx::KernelCapabilityEntry::getType() const
+nn::hac::kc::KernelCapId nn::hac::KernelCapabilityEntry::getType() const
 {
 	return mType;
 }
 
-void nx::KernelCapabilityEntry::setType(kc::KernelCapId type)
+void nn::hac::KernelCapabilityEntry::setType(kc::KernelCapId type)
 {
 	mType = type;
 }
 
-uint32_t nx::KernelCapabilityEntry::getField() const
+uint32_t nn::hac::KernelCapabilityEntry::getField() const
 {
 	return mField & getFieldMask();
 }
 
-void nx::KernelCapabilityEntry::setField(uint32_t field)
+void nn::hac::KernelCapabilityEntry::setField(uint32_t field)
 {
 	mField = field;
 }

lib/libhac/source/KernelVersionEntry.cpp

@@ -1,12 +1,12 @@
-#include <nx/KernelVersionEntry.h>
+#include <nn/hac/KernelVersionEntry.h>
 
-nx::KernelVersionEntry::KernelVersionEntry() :
+nn::hac::KernelVersionEntry::KernelVersionEntry() :
 	mCap(kCapId),
 	mVerMajor(0),
 	mVerMinor(0)
 {}
 
-nx::KernelVersionEntry::KernelVersionEntry(const KernelCapabilityEntry & kernel_cap) :
+nn::hac::KernelVersionEntry::KernelVersionEntry(const KernelCapabilityEntry & kernel_cap) :
 	mCap(kCapId),
 	mVerMajor(0),
 	mVerMinor(0)
@@ -14,7 +14,7 @@ nx::KernelVersionEntry::KernelVersionEntry(const KernelCapabilityEntry & kernel_
 	setKernelCapability(kernel_cap);
 }
 
-nx::KernelVersionEntry::KernelVersionEntry(uint16_t major, uint8_t minor) :
+nn::hac::KernelVersionEntry::KernelVersionEntry(uint16_t major, uint8_t minor) :
 	mCap(kCapId),
 	mVerMajor(0),
 	mVerMinor(0)
@@ -23,30 +23,30 @@ nx::KernelVersionEntry::KernelVersionEntry(uint16_t major, uint8_t minor) :
 	setVerMinor(minor);
 }
 
-void nx::KernelVersionEntry::operator=(const KernelVersionEntry& other)
+void nn::hac::KernelVersionEntry::operator=(const KernelVersionEntry& other)
 {
 	mVerMajor = other.mVerMajor;
 	mVerMinor = other.mVerMinor;
 	updateCapField();
 }
 
-bool nx::KernelVersionEntry::operator==(const KernelVersionEntry& other) const
+bool nn::hac::KernelVersionEntry::operator==(const KernelVersionEntry& other) const
 {
 	return (mVerMajor == other.mVerMajor) \
 		&& (mVerMinor == other.mVerMinor);
 }
 
-bool nx::KernelVersionEntry::operator!=(const KernelVersionEntry& other) const
+bool nn::hac::KernelVersionEntry::operator!=(const KernelVersionEntry& other) const
 {
 	return !(*this == other);
 }
 
-const nx::KernelCapabilityEntry & nx::KernelVersionEntry::getKernelCapability() const
+const nn::hac::KernelCapabilityEntry & nn::hac::KernelVersionEntry::getKernelCapability() const
 {
 	return mCap;
 }
 
-void nx::KernelVersionEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
+void nn::hac::KernelVersionEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
 {
 	if (kernel_cap.getType() != kCapId)
 	{
@@ -57,12 +57,12 @@ void nx::KernelVersionEntry::setKernelCapability(const KernelCapabilityEntry & k
 	processCapField();
 }
 
-uint16_t nx::KernelVersionEntry::getVerMajor() const
+uint16_t nn::hac::KernelVersionEntry::getVerMajor() const
 {
 	return mVerMajor;
 }
 
-void nx::KernelVersionEntry::setVerMajor(uint16_t major)
+void nn::hac::KernelVersionEntry::setVerMajor(uint16_t major)
 {
 	if (major > kVerMajorMax)
 	{
@@ -73,12 +73,12 @@ void nx::KernelVersionEntry::setVerMajor(uint16_t major)
 	updateCapField();
 }
 
-uint8_t nx::KernelVersionEntry::getVerMinor() const
+uint8_t nn::hac::KernelVersionEntry::getVerMinor() const
 {
 	return mVerMinor;
 }
 
-void nx::KernelVersionEntry::setVerMinor(uint8_t minor)
+void nn::hac::KernelVersionEntry::setVerMinor(uint8_t minor)
 {
 	if (minor > kVerMinorMax)
 	{

lib/libhac/source/KernelVersionHandler.cpp

@@ -1,28 +1,28 @@
-#include <nx/KernelVersionHandler.h>
+#include <nn/hac/KernelVersionHandler.h>
 
-nx::KernelVersionHandler::KernelVersionHandler() :
+nn::hac::KernelVersionHandler::KernelVersionHandler() :
 	mIsSet(false),
 	mEntry(0,0)
 {}
 
-void nx::KernelVersionHandler::operator=(const KernelVersionHandler & other)
+void nn::hac::KernelVersionHandler::operator=(const KernelVersionHandler & other)
 {
 	mIsSet = other.mIsSet;
 	mEntry.setKernelCapability(other.mEntry.getKernelCapability());
 }
 
-bool nx::KernelVersionHandler::operator==(const KernelVersionHandler & other) const
+bool nn::hac::KernelVersionHandler::operator==(const KernelVersionHandler & other) const
 {
 	return (mIsSet == other.mIsSet) \
 		&& (mEntry.getKernelCapability() == other.mEntry.getKernelCapability());
 }
 
-bool nx::KernelVersionHandler::operator!=(const KernelVersionHandler & other) const
+bool nn::hac::KernelVersionHandler::operator!=(const KernelVersionHandler & other) const
 {
 	return !(*this == other);
 }
 
-void nx::KernelVersionHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
+void nn::hac::KernelVersionHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
 {
 	if (caps.size() > kMaxKernelCapNum)
 	{ 
@@ -37,7 +37,7 @@ void nx::KernelVersionHandler::importKernelCapabilityList(const fnd::List<Kernel
 	mIsSet = true;
 }
 
-void nx::KernelVersionHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
+void nn::hac::KernelVersionHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
 {
 	if (isSet() == false)
 		return;
@@ -45,35 +45,35 @@ void nx::KernelVersionHandler::exportKernelCapabilityList(fnd::List<KernelCapabi
 	caps.addElement(mEntry.getKernelCapability());
 }
 
-void nx::KernelVersionHandler::clear()
+void nn::hac::KernelVersionHandler::clear()
 {
 	mIsSet = false;
 	mEntry.setVerMajor(0);
 	mEntry.setVerMinor(0);
 }
 
-bool nx::KernelVersionHandler::isSet() const
+bool nn::hac::KernelVersionHandler::isSet() const
 {
 	return mIsSet;
 }
 
-uint16_t nx::KernelVersionHandler::getVerMajor() const
+uint16_t nn::hac::KernelVersionHandler::getVerMajor() const
 {
 	return mEntry.getVerMajor();
 }
 
-void nx::KernelVersionHandler::setVerMajor(uint16_t major)
+void nn::hac::KernelVersionHandler::setVerMajor(uint16_t major)
 {
 	mEntry.setVerMajor(major);
 	mIsSet = true;
 }
 
-uint8_t nx::KernelVersionHandler::getVerMinor() const
+uint8_t nn::hac::KernelVersionHandler::getVerMinor() const
 {
 	return mEntry.getVerMinor();
 }
 
-void nx::KernelVersionHandler::setVerMinor(uint8_t minor)
+void nn::hac::KernelVersionHandler::setVerMinor(uint8_t minor)
 {
 	mEntry.setVerMinor(minor);
 	mIsSet = true;

lib/libhac/source/MemoryMappingHandler.cpp

@@ -1,30 +1,30 @@
-#include <nx/MemoryMappingHandler.h>
+#include <nn/hac/MemoryMappingHandler.h>
-#include <nx/MemoryPageEntry.h>
+#include <nn/hac/MemoryPageEntry.h>
 
-nx::MemoryMappingHandler::MemoryMappingHandler() :
+nn::hac::MemoryMappingHandler::MemoryMappingHandler() :
 	mIsSet(false)
 {}
 
-void nx::MemoryMappingHandler::operator=(const MemoryMappingHandler & other)
+void nn::hac::MemoryMappingHandler::operator=(const MemoryMappingHandler & other)
 {
 	mIsSet = other.mIsSet;
 	mMemRange = other.mMemRange;
 	mMemPage = other.mMemPage;
 }
 
-bool nx::MemoryMappingHandler::operator==(const MemoryMappingHandler & other) const
+bool nn::hac::MemoryMappingHandler::operator==(const MemoryMappingHandler & other) const
 {
 	return (mIsSet == other.mIsSet) \
 		&& (mMemRange == other.mMemRange) \
 		&& (mMemPage == other.mMemPage);
 }
 
-bool nx::MemoryMappingHandler::operator!=(const MemoryMappingHandler & other) const
+bool nn::hac::MemoryMappingHandler::operator!=(const MemoryMappingHandler & other) const
 {
 	return !(*this == other);
 }
 
-void nx::MemoryMappingHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
+void nn::hac::MemoryMappingHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
 {
 	if (caps.size() == 0)
 		return;
@@ -87,7 +87,7 @@ void nx::MemoryMappingHandler::importKernelCapabilityList(const fnd::List<Kernel
 	mIsSet = true;
 }
 
-void nx::MemoryMappingHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
+void nn::hac::MemoryMappingHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
 {
 	if (isSet() == false)
 		return;
@@ -116,24 +116,24 @@ void nx::MemoryMappingHandler::exportKernelCapabilityList(fnd::List<KernelCapabi
 	}
 }
 
-void nx::MemoryMappingHandler::clear()
+void nn::hac::MemoryMappingHandler::clear()
 {
 	mIsSet = false;
 	mMemRange.clear();
 	mMemPage.clear();
 }
 
-bool nx::MemoryMappingHandler::isSet() const
+bool nn::hac::MemoryMappingHandler::isSet() const
 {
 	return mIsSet;
 }
 
-const fnd::List<nx::MemoryMappingHandler::sMemoryMapping>& nx::MemoryMappingHandler::getMemoryMaps() const
+const fnd::List<nn::hac::MemoryMappingHandler::sMemoryMapping>& nn::hac::MemoryMappingHandler::getMemoryMaps() const
 {
 	return mMemRange;
 }
 
-const fnd::List<nx::MemoryMappingHandler::sMemoryMapping>& nx::MemoryMappingHandler::getIoMemoryMaps() const
+const fnd::List<nn::hac::MemoryMappingHandler::sMemoryMapping>& nn::hac::MemoryMappingHandler::getIoMemoryMaps() const
 {
 	return mMemPage;
 }

lib/libhac/source/MemoryPageEntry.cpp

@@ -1,13 +1,13 @@
-#include <nx/MemoryPageEntry.h>
+#include <nn/hac/MemoryPageEntry.h>
 
-nx::MemoryPageEntry::MemoryPageEntry() :
+nn::hac::MemoryPageEntry::MemoryPageEntry() :
 	mCap(kc::KC_INVALID),
 	mPage(0),
 	mFlag(false),
 	mUseFlag(false)
 {}
 
-nx::MemoryPageEntry::MemoryPageEntry(const KernelCapabilityEntry & kernel_cap) :
+nn::hac::MemoryPageEntry::MemoryPageEntry(const KernelCapabilityEntry & kernel_cap) :
 	mCap(kc::KC_INVALID),
 	mPage(0),
 	mFlag(false),
@@ -16,7 +16,7 @@ nx::MemoryPageEntry::MemoryPageEntry(const KernelCapabilityEntry & kernel_cap) :
 	setKernelCapability(kernel_cap);
 }
 
-nx::MemoryPageEntry::MemoryPageEntry(uint32_t page) :
+nn::hac::MemoryPageEntry::MemoryPageEntry(uint32_t page) :
 	mCap(kc::KC_INVALID),
 	mPage(0),
 	mFlag(false),
@@ -25,7 +25,7 @@ nx::MemoryPageEntry::MemoryPageEntry(uint32_t page) :
 	setPage(page);
 }
 
-nx::MemoryPageEntry::MemoryPageEntry(uint32_t page, bool flag) :
+nn::hac::MemoryPageEntry::MemoryPageEntry(uint32_t page, bool flag) :
 	mCap(kc::KC_INVALID),
 	mPage(0),
 	mFlag(false),
@@ -35,7 +35,7 @@ nx::MemoryPageEntry::MemoryPageEntry(uint32_t page, bool flag) :
 	setFlag(flag);
 }
 
-void nx::MemoryPageEntry::operator=(const MemoryPageEntry& other)
+void nn::hac::MemoryPageEntry::operator=(const MemoryPageEntry& other)
 {
 	mPage = other.mPage;
 	mFlag = other.mFlag;
@@ -43,24 +43,24 @@ void nx::MemoryPageEntry::operator=(const MemoryPageEntry& other)
 	updateCapField();
 }
 
-bool nx::MemoryPageEntry::operator==(const MemoryPageEntry& other) const
+bool nn::hac::MemoryPageEntry::operator==(const MemoryPageEntry& other) const
 {
 	return (mPage == other.mPage) \
 		&& (mFlag == other.mFlag) \
 		&& (mUseFlag == other.mUseFlag);
 }
 
-bool nx::MemoryPageEntry::operator!=(const MemoryPageEntry& other) const
+bool nn::hac::MemoryPageEntry::operator!=(const MemoryPageEntry& other) const
 {
 	return !(*this == other);
 }
 
-const nx::KernelCapabilityEntry & nx::MemoryPageEntry::getKernelCapability() const
+const nn::hac::KernelCapabilityEntry & nn::hac::MemoryPageEntry::getKernelCapability() const
 {
 	return mCap;
 }
 
-void nx::MemoryPageEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
+void nn::hac::MemoryPageEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
 {
 	if (kernel_cap.getType() != kc::KC_MEMORY_MAP && kernel_cap.getType() != kc::KC_IO_MEMORY_MAP)
 	{
@@ -71,12 +71,12 @@ void nx::MemoryPageEntry::setKernelCapability(const KernelCapabilityEntry & kern
 	processCapField();
 }
 
-uint32_t nx::MemoryPageEntry::getPage() const
+uint32_t nn::hac::MemoryPageEntry::getPage() const
 {
 	return mPage;
 }
 
-void nx::MemoryPageEntry::setPage(uint32_t page)
+void nn::hac::MemoryPageEntry::setPage(uint32_t page)
 {
 	if (page > kMaxPage)
 	{
@@ -87,23 +87,23 @@ void nx::MemoryPageEntry::setPage(uint32_t page)
 	updateCapField();
 }
 
-bool nx::MemoryPageEntry::getFlag() const
+bool nn::hac::MemoryPageEntry::getFlag() const
 {
 	return mFlag;
 }
 
-void nx::MemoryPageEntry::setFlag(bool flag)
+void nn::hac::MemoryPageEntry::setFlag(bool flag)
 {
 	mFlag = flag;
 	updateCapField();
 }
 
-bool nx::MemoryPageEntry::isMultiplePages() const
+bool nn::hac::MemoryPageEntry::isMultiplePages() const
 {
 	return mUseFlag;
 }
 
-void nx::MemoryPageEntry::setMapMultiplePages(bool useFlag)
+void nn::hac::MemoryPageEntry::setMapMultiplePages(bool useFlag)
 {
 	mUseFlag = useFlag;
 }

lib/libhac/source/MiscFlagsEntry.cpp

@@ -1,46 +1,46 @@
-#include <nx/MiscFlagsEntry.h>
+#include <nn/hac/MiscFlagsEntry.h>
 
-nx::MiscFlagsEntry::MiscFlagsEntry() :
+nn::hac::MiscFlagsEntry::MiscFlagsEntry() :
 	mCap(kCapId),
 	mFlags(0)
 {}
 
-nx::MiscFlagsEntry::MiscFlagsEntry(const KernelCapabilityEntry & kernel_cap) :
+nn::hac::MiscFlagsEntry::MiscFlagsEntry(const KernelCapabilityEntry & kernel_cap) :
 	mCap(kCapId),
 	mFlags(0)
 {
 	setKernelCapability(kernel_cap);
 }
 
-nx::MiscFlagsEntry::MiscFlagsEntry(uint32_t flags) :
+nn::hac::MiscFlagsEntry::MiscFlagsEntry(uint32_t flags) :
 	mCap(kCapId),
 	mFlags(0)
 {
 	setFlags(flags);
 }
 
-void nx::MiscFlagsEntry::operator=(const MiscFlagsEntry& other)
+void nn::hac::MiscFlagsEntry::operator=(const MiscFlagsEntry& other)
 {
 	mFlags = other.mFlags;
 	updateCapField();
 }
 
-bool nx::MiscFlagsEntry::operator==(const MiscFlagsEntry& other) const
+bool nn::hac::MiscFlagsEntry::operator==(const MiscFlagsEntry& other) const
 {
 	return (mFlags == other.mFlags);
 }
 
-bool nx::MiscFlagsEntry::operator!=(const MiscFlagsEntry& other) const
+bool nn::hac::MiscFlagsEntry::operator!=(const MiscFlagsEntry& other) const
 {
 	return !(*this == other);
 }
 
-const nx::KernelCapabilityEntry & nx::MiscFlagsEntry::getKernelCapability() const
+const nn::hac::KernelCapabilityEntry & nn::hac::MiscFlagsEntry::getKernelCapability() const
 {
 	return mCap;
 }
 
-void nx::MiscFlagsEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
+void nn::hac::MiscFlagsEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
 {
 	if (kernel_cap.getType() != kCapId)
 	{
@@ -51,12 +51,12 @@ void nx::MiscFlagsEntry::setKernelCapability(const KernelCapabilityEntry & kerne
 	processCapField();
 }
 
-uint32_t nx::MiscFlagsEntry::getFlags() const
+uint32_t nn::hac::MiscFlagsEntry::getFlags() const
 {
 	return mFlags;
 }
 
-void nx::MiscFlagsEntry::setFlags(uint32_t flags)
+void nn::hac::MiscFlagsEntry::setFlags(uint32_t flags)
 {
 	if ((flags & ~kMaxVal) != 0)
 	{

lib/libhac/source/MiscFlagsHandler.cpp

@@ -1,27 +1,27 @@
-#include <nx/MiscFlagsHandler.h>
+#include <nn/hac/MiscFlagsHandler.h>
 
-nx::MiscFlagsHandler::MiscFlagsHandler() :
+nn::hac::MiscFlagsHandler::MiscFlagsHandler() :
 	mIsSet(false)
 {}
 
-void nx::MiscFlagsHandler::operator=(const MiscFlagsHandler & other)
+void nn::hac::MiscFlagsHandler::operator=(const MiscFlagsHandler & other)
 {
 	mIsSet = other.mIsSet;
 	mFlags = other.mFlags;
 }
 
-bool nx::MiscFlagsHandler::operator==(const MiscFlagsHandler & other) const
+bool nn::hac::MiscFlagsHandler::operator==(const MiscFlagsHandler & other) const
 {
 	return (mIsSet == other.mIsSet) \
 		&& (mFlags == other.mFlags);
 }
 
-bool nx::MiscFlagsHandler::operator!=(const MiscFlagsHandler & other) const
+bool nn::hac::MiscFlagsHandler::operator!=(const MiscFlagsHandler & other) const
 {
 	return !(*this == other);
 }
 
-void nx::MiscFlagsHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
+void nn::hac::MiscFlagsHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
 {
 	if (caps.size() > kMaxKernelCapNum)
 	{
@@ -46,7 +46,7 @@ void nx::MiscFlagsHandler::importKernelCapabilityList(const fnd::List<KernelCapa
 	mIsSet = true;
 }
 
-void nx::MiscFlagsHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
+void nn::hac::MiscFlagsHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
 {
 	if (isSet() == false)
 		return;
@@ -66,23 +66,23 @@ void nx::MiscFlagsHandler::exportKernelCapabilityList(fnd::List<KernelCapability
 	caps.addElement(entry.getKernelCapability());
 }
 
-void nx::MiscFlagsHandler::clear()
+void nn::hac::MiscFlagsHandler::clear()
 {
 	mIsSet = false;
 	mFlags.clear();
 }
 
-bool nx::MiscFlagsHandler::isSet() const
+bool nn::hac::MiscFlagsHandler::isSet() const
 {
 	return mIsSet;
 }
 
-const fnd::List<nx::MiscFlagsHandler::Flags>& nx::MiscFlagsHandler::getFlagList() const
+const fnd::List<nn::hac::MiscFlagsHandler::Flags>& nn::hac::MiscFlagsHandler::getFlagList() const
 {
 	return mFlags;
 }
 
-void nx::MiscFlagsHandler::setFlagList(fnd::List<Flags> flags)
+void nn::hac::MiscFlagsHandler::setFlagList(fnd::List<Flags> flags)
 {
 	mFlags = flags;
 	mIsSet = true;

lib/libhac/source/MiscParamsEntry.cpp

@@ -1,46 +1,46 @@
-#include <nx/MiscParamsEntry.h>
+#include <nn/hac/MiscParamsEntry.h>
 
-nx::MiscParamsEntry::MiscParamsEntry() :
+nn::hac::MiscParamsEntry::MiscParamsEntry() :
 	mCap(kCapId),
 	mProgramType(0)
 {}
 
-nx::MiscParamsEntry::MiscParamsEntry(const KernelCapabilityEntry & kernel_cap) :
+nn::hac::MiscParamsEntry::MiscParamsEntry(const KernelCapabilityEntry & kernel_cap) :
 	mCap(kCapId),
 	mProgramType(0)
 {
 	setKernelCapability(kernel_cap);
 }
 
-nx::MiscParamsEntry::MiscParamsEntry(uint8_t program_type) :
+nn::hac::MiscParamsEntry::MiscParamsEntry(uint8_t program_type) :
 	mCap(kCapId),
 	mProgramType(0)
 {
 	setProgramType(program_type);
 }
 
-void nx::MiscParamsEntry::operator=(const MiscParamsEntry& other)
+void nn::hac::MiscParamsEntry::operator=(const MiscParamsEntry& other)
 {
 	mProgramType = other.mProgramType;
 	updateCapField();
 }
 
-bool nx::MiscParamsEntry::operator==(const MiscParamsEntry& other) const
+bool nn::hac::MiscParamsEntry::operator==(const MiscParamsEntry& other) const
 {
 	return (mProgramType == other.mProgramType);
 }
 
-bool nx::MiscParamsEntry::operator!=(const MiscParamsEntry& other) const
+bool nn::hac::MiscParamsEntry::operator!=(const MiscParamsEntry& other) const
 {
 	return !(*this == other);
 }
 
-const nx::KernelCapabilityEntry & nx::MiscParamsEntry::getKernelCapability() const
+const nn::hac::KernelCapabilityEntry & nn::hac::MiscParamsEntry::getKernelCapability() const
 {
 	return mCap;
 }
 
-void nx::MiscParamsEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
+void nn::hac::MiscParamsEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
 {
 	if (kernel_cap.getType() != kCapId)
 	{
@@ -51,12 +51,12 @@ void nx::MiscParamsEntry::setKernelCapability(const KernelCapabilityEntry & kern
 	processCapField();
 }
 
-uint8_t nx::MiscParamsEntry::getProgramType() const
+uint8_t nn::hac::MiscParamsEntry::getProgramType() const
 {
 	return mProgramType;
 }
 
-void nx::MiscParamsEntry::setProgramType(uint8_t type)
+void nn::hac::MiscParamsEntry::setProgramType(uint8_t type)
 {
 	if (type > kMaxProgramType)
 	{

lib/libhac/source/MiscParamsHandler.cpp

@@ -1,28 +1,28 @@
-#include <nx/MiscParamsHandler.h>
+#include <nn/hac/MiscParamsHandler.h>
 
-nx::MiscParamsHandler::MiscParamsHandler() :
+nn::hac::MiscParamsHandler::MiscParamsHandler() :
 	mIsSet(false),
 	mEntry(0)
 {}
 
-void nx::MiscParamsHandler::operator=(const MiscParamsHandler & other)
+void nn::hac::MiscParamsHandler::operator=(const MiscParamsHandler & other)
 {
 	mIsSet = other.mIsSet;
 	mEntry.setKernelCapability(other.mEntry.getKernelCapability());
 }
 
-bool nx::MiscParamsHandler::operator==(const MiscParamsHandler & other) const
+bool nn::hac::MiscParamsHandler::operator==(const MiscParamsHandler & other) const
 {
 	return (mIsSet == other.mIsSet) \
 		&& (mEntry.getKernelCapability() == other.mEntry.getKernelCapability());
 }
 
-bool nx::MiscParamsHandler::operator!=(const MiscParamsHandler & other) const
+bool nn::hac::MiscParamsHandler::operator!=(const MiscParamsHandler & other) const
 {
 	return !(*this == other);
 }
 
-void nx::MiscParamsHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
+void nn::hac::MiscParamsHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
 {
 	if (caps.size() > kMaxKernelCapNum)
 	{
@@ -37,7 +37,7 @@ void nx::MiscParamsHandler::importKernelCapabilityList(const fnd::List<KernelCap
 	mIsSet = true;
 }
 
-void nx::MiscParamsHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
+void nn::hac::MiscParamsHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
 {
 	if (isSet() == false)
 		return;
@@ -45,23 +45,23 @@ void nx::MiscParamsHandler::exportKernelCapabilityList(fnd::List<KernelCapabilit
 	caps.addElement(mEntry.getKernelCapability());
 }
 
-void nx::MiscParamsHandler::clear()
+void nn::hac::MiscParamsHandler::clear()
 {
 	mIsSet = false;
 	mEntry.setProgramType(0);
 }
 
-bool nx::MiscParamsHandler::isSet() const
+bool nn::hac::MiscParamsHandler::isSet() const
 {
 	return mIsSet;
 }
 
-uint8_t nx::MiscParamsHandler::getProgramType() const
+uint8_t nn::hac::MiscParamsHandler::getProgramType() const
 {
 	return mEntry.getProgramType();
 }
 
-void nx::MiscParamsHandler::setProgramType(uint8_t type)
+void nn::hac::MiscParamsHandler::setProgramType(uint8_t type)
 {
 	mEntry.setProgramType(type);
 	mIsSet = true;

lib/libhac/source/NcaHeader.cpp

@@ -1,16 +1,16 @@
-#include <nx/NcaHeader.h>
+#include <nn/hac/NcaHeader.h>
 
-nx::NcaHeader::NcaHeader()
+nn::hac::NcaHeader::NcaHeader()
 {
 	clear();
 }
 
-nx::NcaHeader::NcaHeader(const NcaHeader & other)
+nn::hac::NcaHeader::NcaHeader(const NcaHeader & other)
 {
 	*this = other;
 }
 
-bool nx::NcaHeader::operator==(const NcaHeader & other) const
+bool nn::hac::NcaHeader::operator==(const NcaHeader & other) const
 {
 	return (mDistributionType == other.mDistributionType) \
 		&& (mContentType == other.mContentType) \
@@ -24,12 +24,12 @@ bool nx::NcaHeader::operator==(const NcaHeader & other) const
 		&& (mEncAesKeys == other.mEncAesKeys);
 }
 
-bool nx::NcaHeader::operator!=(const NcaHeader & other) const
+bool nn::hac::NcaHeader::operator!=(const NcaHeader & other) const
 {
 	return !(*this == other);
 }
 
-void nx::NcaHeader::operator=(const NcaHeader & other)
+void nn::hac::NcaHeader::operator=(const NcaHeader & other)
 {
 	if (other.getBytes().size())
 	{
@@ -51,7 +51,7 @@ void nx::NcaHeader::operator=(const NcaHeader & other)
 	}
 }
 
-void nx::NcaHeader::toBytes()
+void nn::hac::NcaHeader::toBytes()
 {
 	mRawBinary.alloc(sizeof(sNcaHeader));
 	sNcaHeader* hdr = (sNcaHeader*)mRawBinary.data();
@@ -108,7 +108,7 @@ void nx::NcaHeader::toBytes()
 	}
 }
 
-void nx::NcaHeader::fromBytes(const byte_t * data, size_t len)
+void nn::hac::NcaHeader::fromBytes(const byte_t * data, size_t len)
 {
 	if (len < sizeof(sNcaHeader))
 	{
@@ -158,12 +158,12 @@ void nx::NcaHeader::fromBytes(const byte_t * data, size_t len)
 	}
 }
 
-const fnd::Vec<byte_t>& nx::NcaHeader::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::NcaHeader::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::NcaHeader::clear()
+void nn::hac::NcaHeader::clear()
 {
 	mFormatVersion = NCA3_FORMAT;
 	mDistributionType = nca::DIST_DOWNLOAD;
@@ -179,97 +179,97 @@ void nx::NcaHeader::clear()
 	mEncAesKeys.clear();
 }
 
-nx::NcaHeader::FormatVersion nx::NcaHeader::getFormatVersion() const
+nn::hac::NcaHeader::FormatVersion nn::hac::NcaHeader::getFormatVersion() const
 {
 	return mFormatVersion;
 }
 
-void nx::NcaHeader::setFormatVersion(FormatVersion version)
+void nn::hac::NcaHeader::setFormatVersion(FormatVersion version)
 {
 	mFormatVersion = version;
 }
 
-nx::nca::DistributionType nx::NcaHeader::getDistributionType() const
+nn::hac::nca::DistributionType nn::hac::NcaHeader::getDistributionType() const
 {
 	return mDistributionType;
 }
 
-void nx::NcaHeader::setDistributionType(nca::DistributionType type)
+void nn::hac::NcaHeader::setDistributionType(nca::DistributionType type)
 {
 	mDistributionType = type;
 }
 
-nx::nca::ContentType nx::NcaHeader::getContentType() const
+nn::hac::nca::ContentType nn::hac::NcaHeader::getContentType() const
 {
 	return mContentType;
 }
 
-void nx::NcaHeader::setContentType(nca::ContentType type)
+void nn::hac::NcaHeader::setContentType(nca::ContentType type)
 {
 	mContentType = type;
 }
 
-byte_t nx::NcaHeader::getKeyGeneration() const
+byte_t nn::hac::NcaHeader::getKeyGeneration() const
 {
 	return mKeyGeneration;
 }
 
-void nx::NcaHeader::setKeyGeneration(byte_t gen)
+void nn::hac::NcaHeader::setKeyGeneration(byte_t gen)
 {
 	mKeyGeneration = gen;
 }
 
-byte_t nx::NcaHeader::getKaekIndex() const
+byte_t nn::hac::NcaHeader::getKaekIndex() const
 {
 	return mKaekIndex;
 }
 
-void nx::NcaHeader::setKaekIndex(byte_t index)
+void nn::hac::NcaHeader::setKaekIndex(byte_t index)
 {
 	mKaekIndex = index;
 }
 
-uint64_t nx::NcaHeader::getContentSize() const
+uint64_t nn::hac::NcaHeader::getContentSize() const
 {
 	return mContentSize;
 }
 
-void nx::NcaHeader::setContentSize(uint64_t size)
+void nn::hac::NcaHeader::setContentSize(uint64_t size)
 {
 	mContentSize = size;
 }
 
-uint64_t nx::NcaHeader::getProgramId() const
+uint64_t nn::hac::NcaHeader::getProgramId() const
 {
 	return mProgramId;
 }
 
-void nx::NcaHeader::setProgramId(uint64_t program_id)
+void nn::hac::NcaHeader::setProgramId(uint64_t program_id)
 {
 	mProgramId = program_id;
 }
 
-uint32_t nx::NcaHeader::getContentIndex() const
+uint32_t nn::hac::NcaHeader::getContentIndex() const
 {
 	return mContentIndex;
 }
 
-void nx::NcaHeader::setContentIndex(uint32_t index)
+void nn::hac::NcaHeader::setContentIndex(uint32_t index)
 {
 	mContentIndex = index;
 }
 
-uint32_t nx::NcaHeader::getSdkAddonVersion() const
+uint32_t nn::hac::NcaHeader::getSdkAddonVersion() const
 {
 	return mSdkAddonVersion;
 }
 
-void nx::NcaHeader::setSdkAddonVersion(uint32_t version)
+void nn::hac::NcaHeader::setSdkAddonVersion(uint32_t version)
 {
 	mSdkAddonVersion = version;
 }
 
-bool nx::NcaHeader::hasRightsId() const
+bool nn::hac::NcaHeader::hasRightsId() const
 {
 	bool rightsIdIsSet = false;
 
@@ -282,22 +282,22 @@ bool nx::NcaHeader::hasRightsId() const
 	return rightsIdIsSet;
 }
 
-const byte_t* nx::NcaHeader::getRightsId() const
+const byte_t* nn::hac::NcaHeader::getRightsId() const
 {
 	return mRightsId;
 }
 
-void nx::NcaHeader::setRightsId(const byte_t* rights_id)
+void nn::hac::NcaHeader::setRightsId(const byte_t* rights_id)
 {
 	memcpy(mRightsId, rights_id, nca::kRightsIdLen);
 }
 
-const fnd::List<nx::NcaHeader::sPartition>& nx::NcaHeader::getPartitions() const
+const fnd::List<nn::hac::NcaHeader::sPartition>& nn::hac::NcaHeader::getPartitions() const
 {
 	return mPartitions;
 }
 
-void nx::NcaHeader::setPartitions(const fnd::List<nx::NcaHeader::sPartition>& partitions)
+void nn::hac::NcaHeader::setPartitions(const fnd::List<nn::hac::NcaHeader::sPartition>& partitions)
 {
 	mPartitions = partitions;
 	if (mPartitions.size() >= nca::kPartitionNum)
@@ -306,22 +306,22 @@ void nx::NcaHeader::setPartitions(const fnd::List<nx::NcaHeader::sPartition>& pa
 	}
 }
 
-const fnd::List<crypto::aes::sAes128Key>& nx::NcaHeader::getEncAesKeys() const
+const fnd::List<crypto::aes::sAes128Key>& nn::hac::NcaHeader::getEncAesKeys() const
 {
 	return mEncAesKeys;
 }
 
-void nx::NcaHeader::setEncAesKeys(const fnd::List<crypto::aes::sAes128Key>& keys)
+void nn::hac::NcaHeader::setEncAesKeys(const fnd::List<crypto::aes::sAes128Key>& keys)
 {
 	mEncAesKeys = keys;
 }
 
-uint64_t nx::NcaHeader::blockNumToSize(uint32_t block_num) const
+uint64_t nn::hac::NcaHeader::blockNumToSize(uint32_t block_num) const
 {
 	return block_num*nca::kSectorSize;
 }
 
-uint32_t nx::NcaHeader::sizeToBlockNum(uint64_t real_size) const
+uint32_t nn::hac::NcaHeader::sizeToBlockNum(uint64_t real_size) const
 {
 	return (uint32_t)(align(real_size, nca::kSectorSize) / nca::kSectorSize);
 }

lib/libhac/source/NcaUtils.cpp

@@ -1,25 +1,25 @@
-#include <nx/NcaUtils.h>
+#include <nn/hac/NcaUtils.h>
 
-void nx::NcaUtils::decryptNcaHeader(const byte_t* src, byte_t* dst, const crypto::aes::sAesXts128Key& key)
+void nn::hac::NcaUtils::decryptNcaHeader(const byte_t* src, byte_t* dst, const crypto::aes::sAesXts128Key& key)
 {
 	byte_t tweak[crypto::aes::kAesBlockSize];
 
 	// decrypt main header
-	byte_t raw_hdr[nx::nca::kSectorSize];
+	byte_t raw_hdr[nn::hac::nca::kSectorSize];
 	crypto::aes::AesXtsMakeTweak(tweak, 1);
-	crypto::aes::AesXtsDecryptSector(src + sectorToOffset(1), nx::nca::kSectorSize, key.key[0], key.key[1], tweak, raw_hdr);
+	crypto::aes::AesXtsDecryptSector(src + sectorToOffset(1), nn::hac::nca::kSectorSize, key.key[0], key.key[1], tweak, raw_hdr);
 
-	bool useNca2SectorIndex = ((nx::sNcaHeader*)(raw_hdr))->st_magic.get() == nx::nca::kNca2StructMagic;
+	bool useNca2SectorIndex = ((nn::hac::sNcaHeader*)(raw_hdr))->st_magic.get() == nn::hac::nca::kNca2StructMagic;
 
 	// decrypt whole header
-	for (size_t i = 0; i < nx::nca::kHeaderSectorNum; i++)
+	for (size_t i = 0; i < nn::hac::nca::kHeaderSectorNum; i++)
 	{
 		crypto::aes::AesXtsMakeTweak(tweak, (i > 1 && useNca2SectorIndex)? 0 : i);
-		crypto::aes::AesXtsDecryptSector(src + sectorToOffset(i), nx::nca::kSectorSize, key.key[0], key.key[1], tweak, dst + sectorToOffset(i));
+		crypto::aes::AesXtsDecryptSector(src + sectorToOffset(i), nn::hac::nca::kSectorSize, key.key[0], key.key[1], tweak, dst + sectorToOffset(i));
 	}
 }
 
-byte_t nx::NcaUtils::getMasterKeyRevisionFromKeyGeneration(byte_t key_generation)
+byte_t nn::hac::NcaUtils::getMasterKeyRevisionFromKeyGeneration(byte_t key_generation)
 {
 	byte_t masterkey_rev;
 
@@ -48,7 +48,7 @@ byte_t nx::NcaUtils::getMasterKeyRevisionFromKeyGeneration(byte_t key_generation
 	return masterkey_rev;
 }
 
-void nx::NcaUtils::getNcaPartitionAesCtr(const nx::sNcaFsHeader* hdr, byte_t* ctr)
+void nn::hac::NcaUtils::getNcaPartitionAesCtr(const nn::hac::sNcaFsHeader* hdr, byte_t* ctr)
 {
 	for (size_t i = 0; i < 8; i++)
 	{

lib/libhac/source/NpdmBinary.cpp

@@ -1,19 +1,19 @@
-#include <nx/NpdmBinary.h>
+#include <nn/hac/NpdmBinary.h>
 
 #include <fnd/SimpleTextOutput.h>
 
-nx::NpdmBinary::NpdmBinary()
+nn::hac::NpdmBinary::NpdmBinary()
 {
 	clear();
 }
 
-nx::NpdmBinary::NpdmBinary(const NpdmBinary & other) :
+nn::hac::NpdmBinary::NpdmBinary(const NpdmBinary & other) :
 	NpdmBinary()
 {
 	*this = other;
 }
 
-void nx::NpdmBinary::operator=(const NpdmBinary & other)
+void nn::hac::NpdmBinary::operator=(const NpdmBinary & other)
 {
 	mRawBinary = other.mRawBinary;
 	mInstructionType = other.mInstructionType;
@@ -28,7 +28,7 @@ void nx::NpdmBinary::operator=(const NpdmBinary & other)
 	mAcid = other.mAcid;
 }
 
-bool nx::NpdmBinary::operator==(const NpdmBinary & other) const
+bool nn::hac::NpdmBinary::operator==(const NpdmBinary & other) const
 {
 	return (mInstructionType == other.mInstructionType) \
 		&& (mProcAddressSpaceType == other.mProcAddressSpaceType) \
@@ -42,12 +42,12 @@ bool nx::NpdmBinary::operator==(const NpdmBinary & other) const
 		&& (mAcid == other.mAcid);
 }
 
-bool nx::NpdmBinary::operator!=(const NpdmBinary & other) const
+bool nn::hac::NpdmBinary::operator!=(const NpdmBinary & other) const
 {
 	return !(*this == other);
 }
 
-void nx::NpdmBinary::toBytes()
+void nn::hac::NpdmBinary::toBytes()
 {
 	if (mAcid.getBytes().size() == 0)
 		mAcid.toBytes();
@@ -103,7 +103,7 @@ void nx::NpdmBinary::toBytes()
 	}
 }
 
-void nx::NpdmBinary::fromBytes(const byte_t* data, size_t len)
+void nn::hac::NpdmBinary::fromBytes(const byte_t* data, size_t len)
 {
 	// check size
 	if (len < sizeof(sNpdmHeader))
@@ -167,12 +167,12 @@ void nx::NpdmBinary::fromBytes(const byte_t* data, size_t len)
 	}	
 }
 
-const fnd::Vec<byte_t>& nx::NpdmBinary::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::NpdmBinary::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::NpdmBinary::clear()
+void nn::hac::NpdmBinary::clear()
 {
 	mRawBinary.clear();
 	mInstructionType = npdm::INSTR_64BIT;
@@ -187,32 +187,32 @@ void nx::NpdmBinary::clear()
 	mAcid.clear();
 }
 
-nx::npdm::InstructionType nx::NpdmBinary::getInstructionType() const
+nn::hac::npdm::InstructionType nn::hac::NpdmBinary::getInstructionType() const
 {
 	return mInstructionType;
 }
 
-void nx::NpdmBinary::setInstructionType(npdm::InstructionType type)
+void nn::hac::NpdmBinary::setInstructionType(npdm::InstructionType type)
 {
 	mInstructionType = type;
 }
 
-nx::npdm::ProcAddrSpaceType nx::NpdmBinary::getProcAddressSpaceType() const
+nn::hac::npdm::ProcAddrSpaceType nn::hac::NpdmBinary::getProcAddressSpaceType() const
 {
 	return mProcAddressSpaceType;
 }
 
-void nx::NpdmBinary::setProcAddressSpaceType(npdm::ProcAddrSpaceType type)
+void nn::hac::NpdmBinary::setProcAddressSpaceType(npdm::ProcAddrSpaceType type)
 {
 	mProcAddressSpaceType = type;
 }
 
-byte_t nx::NpdmBinary::getMainThreadPriority() const
+byte_t nn::hac::NpdmBinary::getMainThreadPriority() const
 {
 	return mMainThreadPriority;
 }
 
-void nx::NpdmBinary::setMainThreadPriority(byte_t priority)
+void nn::hac::NpdmBinary::setMainThreadPriority(byte_t priority)
 {
 	if (priority > npdm::kMaxPriority)
 	{
@@ -222,42 +222,42 @@ void nx::NpdmBinary::setMainThreadPriority(byte_t priority)
 	mMainThreadPriority = priority;
 }
 
-byte_t nx::NpdmBinary::getMainThreadCpuId() const
+byte_t nn::hac::NpdmBinary::getMainThreadCpuId() const
 {
 	return mMainThreadCpuId;
 }
 
-void nx::NpdmBinary::setMainThreadCpuId(byte_t core_num)
+void nn::hac::NpdmBinary::setMainThreadCpuId(byte_t core_num)
 {
 	mMainThreadCpuId = core_num;
 }
 
-uint32_t nx::NpdmBinary::getVersion() const
+uint32_t nn::hac::NpdmBinary::getVersion() const
 {
 	return mVersion;
 }
 
-void nx::NpdmBinary::setVersion(uint32_t version)
+void nn::hac::NpdmBinary::setVersion(uint32_t version)
 {
 	mVersion = version;
 }
 
-uint32_t nx::NpdmBinary::getMainThreadStackSize() const
+uint32_t nn::hac::NpdmBinary::getMainThreadStackSize() const
 {
 	return mMainThreadStackSize;
 }
 
-void nx::NpdmBinary::setMainThreadStackSize(uint32_t size)
+void nn::hac::NpdmBinary::setMainThreadStackSize(uint32_t size)
 {
 	mMainThreadStackSize = size;
 }
 
-const std::string & nx::NpdmBinary::getName() const
+const std::string & nn::hac::NpdmBinary::getName() const
 {
 	return mName;
 }
 
-void nx::NpdmBinary::setName(const std::string & name)
+void nn::hac::NpdmBinary::setName(const std::string & name)
 {
 	if (name.length() > npdm::kNameMaxLen)
 	{
@@ -267,12 +267,12 @@ void nx::NpdmBinary::setName(const std::string & name)
 	mName = name;
 }
 
-const std::string & nx::NpdmBinary::getProductCode() const
+const std::string & nn::hac::NpdmBinary::getProductCode() const
 {
 	return mProductCode;
 }
 
-void nx::NpdmBinary::setProductCode(const std::string & product_code)
+void nn::hac::NpdmBinary::setProductCode(const std::string & product_code)
 {
 	if (product_code.length() > npdm::kProductCodeMaxLen)
 	{
@@ -282,22 +282,22 @@ void nx::NpdmBinary::setProductCode(const std::string & product_code)
 	mProductCode = product_code;
 }
 
-const nx::AccessControlInfoBinary & nx::NpdmBinary::getAci() const
+const nn::hac::AccessControlInfoBinary & nn::hac::NpdmBinary::getAci() const
 {
 	return mAci;
 }
 
-void nx::NpdmBinary::setAci(const AccessControlInfoBinary & aci)
+void nn::hac::NpdmBinary::setAci(const AccessControlInfoBinary & aci)
 {
 	mAci = aci;
 }
 
-const nx::AccessControlInfoDescBinary & nx::NpdmBinary::getAcid() const
+const nn::hac::AccessControlInfoDescBinary & nn::hac::NpdmBinary::getAcid() const
 {
 	return mAcid;
 }
 
-void nx::NpdmBinary::setAcid(const AccessControlInfoDescBinary & acid)
+void nn::hac::NpdmBinary::setAcid(const AccessControlInfoDescBinary & acid)
 {
 	mAcid = acid;
 }

lib/libhac/source/NroHeader.cpp

@@ -1,16 +1,16 @@
-#include <nx/NroHeader.h>
+#include <nn/hac/NroHeader.h>
 
-nx::NroHeader::NroHeader()
+nn::hac::NroHeader::NroHeader()
 {
 	clear();
 }
 
-nx::NroHeader::NroHeader(const NroHeader& other)
+nn::hac::NroHeader::NroHeader(const NroHeader& other)
 {
 	*this = other;
 }
 
-void nx::NroHeader::operator=(const NroHeader& other)
+void nn::hac::NroHeader::operator=(const NroHeader& other)
 {
 	clear();
 	mRoCrt = other.mRoCrt;
@@ -26,7 +26,7 @@ void nx::NroHeader::operator=(const NroHeader& other)
 	mRoDynSymInfo = other.mRoDynSymInfo;
 }
 
-bool nx::NroHeader::operator==(const NroHeader& other) const
+bool nn::hac::NroHeader::operator==(const NroHeader& other) const
 {
 	return (mRoCrt == other.mRoCrt) \
 		&& (mNroSize == other.mNroSize) \
@@ -41,15 +41,15 @@ bool nx::NroHeader::operator==(const NroHeader& other) const
 		&& (mRoDynSymInfo == other.mRoDynSymInfo);
 }
 
-bool nx::NroHeader::operator!=(const NroHeader& other) const
+bool nn::hac::NroHeader::operator!=(const NroHeader& other) const
 {
 	return !(*this == other);
 }
 
-void nx::NroHeader::toBytes()
+void nn::hac::NroHeader::toBytes()
 {
 	mRawBinary.alloc(sizeof(sNroHeader));
-	nx::sNroHeader* hdr = (nx::sNroHeader*)mRawBinary.data();
+	nn::hac::sNroHeader* hdr = (nn::hac::sNroHeader*)mRawBinary.data();
 
 	// set header identifers
 	hdr->st_magic = nro::kNroStructMagic;
@@ -93,7 +93,7 @@ void nx::NroHeader::toBytes()
 	hdr->dyn_sym.size = mRoDynSymInfo.size;
 }
 
-void nx::NroHeader::fromBytes(const byte_t* data, size_t len)
+void nn::hac::NroHeader::fromBytes(const byte_t* data, size_t len)
 {
 	// check input data size
 	if (len < sizeof(sNroHeader))
@@ -109,7 +109,7 @@ void nx::NroHeader::fromBytes(const byte_t* data, size_t len)
 	memcpy(mRawBinary.data(), data, mRawBinary.size());
 
 	// get sNroHeader ptr
-	const nx::sNroHeader* hdr = (const nx::sNroHeader*)mRawBinary.data();
+	const nn::hac::sNroHeader* hdr = (const nn::hac::sNroHeader*)mRawBinary.data();
 	
 	// check NRO signature
 	if (hdr->st_magic.get() != nro::kNroStructMagic)
@@ -150,12 +150,12 @@ void nx::NroHeader::fromBytes(const byte_t* data, size_t len)
 	mRoDynSymInfo.size = hdr->dyn_sym.size.get();
 }
 
-const fnd::Vec<byte_t>& nx::NroHeader::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::NroHeader::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::NroHeader::clear()
+void nn::hac::NroHeader::clear()
 {
 	mRawBinary.clear();
 	memset(&mRoCrt, 0, sizeof(mRoCrt));
@@ -169,102 +169,102 @@ void nx::NroHeader::clear()
 	memset(&mRoDynSymInfo, 0, sizeof(mRoDynSymInfo));
 }
 
-const nx::NroHeader::sRoCrt& nx::NroHeader::getRoCrt() const
+const nn::hac::NroHeader::sRoCrt& nn::hac::NroHeader::getRoCrt() const
 {
 	return mRoCrt;
 }
 
-void nx::NroHeader::setRoCrt(const sRoCrt& ro_crt)
+void nn::hac::NroHeader::setRoCrt(const sRoCrt& ro_crt)
 {
 	mRoCrt = ro_crt;
 }
 
-uint32_t nx::NroHeader::getNroSize() const
+uint32_t nn::hac::NroHeader::getNroSize() const
 {
 	return mNroSize;
 }
 
-void nx::NroHeader::setNroSize(uint32_t size)
+void nn::hac::NroHeader::setNroSize(uint32_t size)
 {
 	mNroSize = size;
 }
 
-const nx::NroHeader::sSection& nx::NroHeader::getTextInfo() const
+const nn::hac::NroHeader::sSection& nn::hac::NroHeader::getTextInfo() const
 {
 	return mTextInfo;
 }
 
-void nx::NroHeader::setTextInfo(const sSection& info)
+void nn::hac::NroHeader::setTextInfo(const sSection& info)
 {
 	mTextInfo = info;
 }
 
-const nx::NroHeader::sSection& nx::NroHeader::getRoInfo() const
+const nn::hac::NroHeader::sSection& nn::hac::NroHeader::getRoInfo() const
 {
 	return mRoInfo;
 }
 
-void nx::NroHeader::setRoInfo(const sSection& info)
+void nn::hac::NroHeader::setRoInfo(const sSection& info)
 {
 	mRoInfo = info;
 }
 
-const nx::NroHeader::sSection& nx::NroHeader::getDataInfo() const
+const nn::hac::NroHeader::sSection& nn::hac::NroHeader::getDataInfo() const
 {
 	return mDataInfo;
 }
 
-void nx::NroHeader::setDataInfo(const sSection& info)
+void nn::hac::NroHeader::setDataInfo(const sSection& info)
 {
 	mDataInfo = info;
 }
 
-uint32_t nx::NroHeader::getBssSize() const
+uint32_t nn::hac::NroHeader::getBssSize() const
 {
 	return mBssSize;
 }
 
-void nx::NroHeader::setBssSize(uint32_t size)
+void nn::hac::NroHeader::setBssSize(uint32_t size)
 {
 	mBssSize = size;
 }
 
-const nx::NroHeader::sModuleId& nx::NroHeader::getModuleId() const
+const nn::hac::NroHeader::sModuleId& nn::hac::NroHeader::getModuleId() const
 {
 	return mModuleId;
 }
 
-void nx::NroHeader::setModuleId(const sModuleId& id)
+void nn::hac::NroHeader::setModuleId(const sModuleId& id)
 {
 	mModuleId = id;
 }
 
-const nx::NroHeader::sSection& nx::NroHeader::getRoEmbeddedInfo() const
+const nn::hac::NroHeader::sSection& nn::hac::NroHeader::getRoEmbeddedInfo() const
 {
 	return mRoEmbeddedInfo;
 }
 
-void nx::NroHeader::setRoEmbeddedInfo(const sSection& info)
+void nn::hac::NroHeader::setRoEmbeddedInfo(const sSection& info)
 {
 	mRoEmbeddedInfo = info;
 }
 
-const nx::NroHeader::sSection& nx::NroHeader::getRoDynStrInfo() const
+const nn::hac::NroHeader::sSection& nn::hac::NroHeader::getRoDynStrInfo() const
 {
 	return mRoDynStrInfo;
 }
 
-void nx::NroHeader::setRoDynStrInfo(const sSection& info)
+void nn::hac::NroHeader::setRoDynStrInfo(const sSection& info)
 {
 	mRoDynStrInfo = info;
 }
 
-const nx::NroHeader::sSection& nx::NroHeader::getRoDynSymInfo() const
+const nn::hac::NroHeader::sSection& nn::hac::NroHeader::getRoDynSymInfo() const
 {
 	return mRoDynSymInfo;
 }
 
-void nx::NroHeader::setRoDynSymInfo(const sSection& info)
+void nn::hac::NroHeader::setRoDynSymInfo(const sSection& info)
 {
 	mRoDynSymInfo = info;
 }

lib/libhac/source/NsoHeader.cpp

@@ -1,16 +1,16 @@
-#include <nx/NsoHeader.h>
+#include <nn/hac/NsoHeader.h>
 
-nx::NsoHeader::NsoHeader()
+nn::hac::NsoHeader::NsoHeader()
 {
 	clear();
 }
 
-nx::NsoHeader::NsoHeader(const NsoHeader& other)
+nn::hac::NsoHeader::NsoHeader(const NsoHeader& other)
 {
 	*this = other;
 }
 
-void nx::NsoHeader::operator=(const NsoHeader& other)
+void nn::hac::NsoHeader::operator=(const NsoHeader& other)
 {
 	clear();
 	mModuleId = other.mModuleId;
@@ -25,7 +25,7 @@ void nx::NsoHeader::operator=(const NsoHeader& other)
 }
 
 
-bool nx::NsoHeader::operator==(const NsoHeader& other) const
+bool nn::hac::NsoHeader::operator==(const NsoHeader& other) const
 {
 	return (mModuleId == other.mModuleId) \
 		&& (mBssSize == other.mBssSize) \
@@ -38,15 +38,15 @@ bool nx::NsoHeader::operator==(const NsoHeader& other) const
 		&& (mRoDynSymInfo == other.mRoDynSymInfo);
 }
 
-bool nx::NsoHeader::operator!=(const NsoHeader& other) const
+bool nn::hac::NsoHeader::operator!=(const NsoHeader& other) const
 {
 	return !(*this == other);
 }
 
-void nx::NsoHeader::toBytes()
+void nn::hac::NsoHeader::toBytes()
 {
 	mRawBinary.alloc(sizeof(sNsoHeader));
-	nx::sNsoHeader* hdr = (nx::sNsoHeader*)mRawBinary.data();
+	nn::hac::sNsoHeader* hdr = (nn::hac::sNsoHeader*)mRawBinary.data();
 
 	// set header identifers
 	hdr->st_magic = nso::kNsoStructMagic;
@@ -125,7 +125,7 @@ void nx::NsoHeader::toBytes()
 	hdr->flags = flags;
 }
 
-void nx::NsoHeader::fromBytes(const byte_t* data, size_t len)
+void nn::hac::NsoHeader::fromBytes(const byte_t* data, size_t len)
 {
 	// check input data size
 	if (len < sizeof(sNsoHeader))
@@ -141,7 +141,7 @@ void nx::NsoHeader::fromBytes(const byte_t* data, size_t len)
 	memcpy(mRawBinary.data(), data, mRawBinary.size());
 
 	// get sNsoHeader ptr
-	const nx::sNsoHeader* hdr = (const nx::sNsoHeader*)mRawBinary.data();
+	const nn::hac::sNsoHeader* hdr = (const nn::hac::sNsoHeader*)mRawBinary.data();
 	
 	// check NSO signature
 	if (hdr->st_magic.get() != nso::kNsoStructMagic)
@@ -196,12 +196,12 @@ void nx::NsoHeader::fromBytes(const byte_t* data, size_t len)
 	mRoDynSymInfo.size = hdr->dyn_sym.size.get();
 }
 
-const fnd::Vec<byte_t>& nx::NsoHeader::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::NsoHeader::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::NsoHeader::clear()
+void nn::hac::NsoHeader::clear()
 {
 	mRawBinary.clear();
 	memset(&mModuleId, 0, sizeof(mModuleId));
@@ -215,92 +215,92 @@ void nx::NsoHeader::clear()
 	memset(&mRoDynSymInfo, 0, sizeof(mRoDynSymInfo));
 }
 
-const nx::NsoHeader::sModuleId& nx::NsoHeader::getModuleId() const
+const nn::hac::NsoHeader::sModuleId& nn::hac::NsoHeader::getModuleId() const
 {
 	return mModuleId;
 }
 
-void nx::NsoHeader::setModuleId(const sModuleId& id)
+void nn::hac::NsoHeader::setModuleId(const sModuleId& id)
 {
 	mModuleId = id;
 }
 
-uint32_t nx::NsoHeader::getBssSize() const
+uint32_t nn::hac::NsoHeader::getBssSize() const
 {
 	return mBssSize;
 }
 
-void nx::NsoHeader::setBssSize(uint32_t size)
+void nn::hac::NsoHeader::setBssSize(uint32_t size)
 {
 	mBssSize = size;
 }
 
-const nx::NsoHeader::sCodeSegment& nx::NsoHeader::getTextSegmentInfo() const
+const nn::hac::NsoHeader::sCodeSegment& nn::hac::NsoHeader::getTextSegmentInfo() const
 {
 	return mTextSegmentInfo;
 }
 
-void nx::NsoHeader::setTextSegmentInfo(const sCodeSegment& info)
+void nn::hac::NsoHeader::setTextSegmentInfo(const sCodeSegment& info)
 {
 	mTextSegmentInfo = info;
 }
 
-const nx::NsoHeader::sCodeSegment& nx::NsoHeader::getRoSegmentInfo() const
+const nn::hac::NsoHeader::sCodeSegment& nn::hac::NsoHeader::getRoSegmentInfo() const
 {
 	return mRoSegmentInfo;
 }
 
-void nx::NsoHeader::setRoSegmentInfo(const sCodeSegment& info)
+void nn::hac::NsoHeader::setRoSegmentInfo(const sCodeSegment& info)
 {
 	mRoSegmentInfo = info;
 }
 
-const nx::NsoHeader::sCodeSegment& nx::NsoHeader::getDataSegmentInfo() const
+const nn::hac::NsoHeader::sCodeSegment& nn::hac::NsoHeader::getDataSegmentInfo() const
 {
 	return mDataSegmentInfo;
 }
 
-void nx::NsoHeader::setDataSegmentInfo(const sCodeSegment& info)
+void nn::hac::NsoHeader::setDataSegmentInfo(const sCodeSegment& info)
 {
 	mDataSegmentInfo = info;
 }
 
-const nx::NsoHeader::sLayout& nx::NsoHeader::getModuleNameInfo() const
+const nn::hac::NsoHeader::sLayout& nn::hac::NsoHeader::getModuleNameInfo() const
 {
 	return mModuleNameInfo;
 }
 
-void nx::NsoHeader::setModuleNameInfo(const sLayout& info)
+void nn::hac::NsoHeader::setModuleNameInfo(const sLayout& info)
 {
 	mModuleNameInfo = info;
 }
 
-const nx::NsoHeader::sLayout& nx::NsoHeader::getRoEmbeddedInfo() const
+const nn::hac::NsoHeader::sLayout& nn::hac::NsoHeader::getRoEmbeddedInfo() const
 {
 	return mRoEmbeddedInfo;
 }
 
-void nx::NsoHeader::setRoEmbeddedInfo(const sLayout& info)
+void nn::hac::NsoHeader::setRoEmbeddedInfo(const sLayout& info)
 {
 	mRoEmbeddedInfo = info;
 }
 
-const nx::NsoHeader::sLayout& nx::NsoHeader::getRoDynStrInfo() const
+const nn::hac::NsoHeader::sLayout& nn::hac::NsoHeader::getRoDynStrInfo() const
 {
 	return mRoDynStrInfo;
 }
 
-void nx::NsoHeader::setRoDynStrInfo(const sLayout& info)
+void nn::hac::NsoHeader::setRoDynStrInfo(const sLayout& info)
 {
 	mRoDynStrInfo = info;
 }
 
-const nx::NsoHeader::sLayout& nx::NsoHeader::getRoDynSymInfo() const
+const nn::hac::NsoHeader::sLayout& nn::hac::NsoHeader::getRoDynSymInfo() const
 {
 	return mRoDynSymInfo;
 }
 
-void nx::NsoHeader::setRoDynSymInfo(const sLayout& info)
+void nn::hac::NsoHeader::setRoDynSymInfo(const sLayout& info)
 {
 	mRoDynSymInfo = info;
 }

lib/libhac/source/PfsHeader.cpp

@@ -1,16 +1,16 @@
-#include <nx/PfsHeader.h>
+#include <nn/hac/PfsHeader.h>
 
-nx::PfsHeader::PfsHeader()
+nn::hac::PfsHeader::PfsHeader()
 {
 	clear();
 }
 
-nx::PfsHeader::PfsHeader(const PfsHeader & other)
+nn::hac::PfsHeader::PfsHeader(const PfsHeader & other)
 {
 	*this = other;
 }
 
-void nx::PfsHeader::operator=(const PfsHeader & other)
+void nn::hac::PfsHeader::operator=(const PfsHeader & other)
 {
 	if (other.getBytes().size())
 	{
@@ -24,24 +24,24 @@ void nx::PfsHeader::operator=(const PfsHeader & other)
 	}
 }
 
-bool nx::PfsHeader::operator==(const PfsHeader & other) const
+bool nn::hac::PfsHeader::operator==(const PfsHeader & other) const
 {
 	return (mFsType == other.mFsType) \
 		&& (mFileList == other.mFileList);
 }
 
-bool nx::PfsHeader::operator!=(const PfsHeader & other) const
+bool nn::hac::PfsHeader::operator!=(const PfsHeader & other) const
 {
 	return !(*this == other);
 }
 
-const fnd::Vec<byte_t>& nx::PfsHeader::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::PfsHeader::getBytes() const
 {
 	return mRawBinary;
 }
 
 
-void nx::PfsHeader::toBytes()
+void nn::hac::PfsHeader::toBytes()
 {
 	// calculate name table size
 	size_t name_table_size = 0;
@@ -113,7 +113,7 @@ void nx::PfsHeader::toBytes()
 	
 }
 
-void nx::PfsHeader::fromBytes(const byte_t* data, size_t len)
+void nn::hac::PfsHeader::fromBytes(const byte_t* data, size_t len)
 {
 	// check input length meets minimum size
 	if (len < sizeof(sPfsHeader))
@@ -195,39 +195,39 @@ void nx::PfsHeader::fromBytes(const byte_t* data, size_t len)
 	
 }
 
-void nx::PfsHeader::clear()
+void nn::hac::PfsHeader::clear()
 {
 	mRawBinary.clear();
 	mFsType = TYPE_PFS0;
 	mFileList.clear();
 }
 
-nx::PfsHeader::FsType nx::PfsHeader::getFsType() const
+nn::hac::PfsHeader::FsType nn::hac::PfsHeader::getFsType() const
 {
 	return mFsType;
 }
 
-void nx::PfsHeader::setFsType(FsType type)
+void nn::hac::PfsHeader::setFsType(FsType type)
 {
 	mFsType = type;
 }
 
-const fnd::List<nx::PfsHeader::sFile>& nx::PfsHeader::getFileList() const
+const fnd::List<nn::hac::PfsHeader::sFile>& nn::hac::PfsHeader::getFileList() const
 {
 	return mFileList;
 }
 
-void nx::PfsHeader::addFile(const std::string & name, size_t size)
+void nn::hac::PfsHeader::addFile(const std::string & name, size_t size)
 {
 	mFileList.addElement({ name, 0, size, 0 });
 }
 
-void nx::PfsHeader::addFile(const std::string & name, size_t size, size_t hash_protected_size, const crypto::sha::sSha256Hash& hash)
+void nn::hac::PfsHeader::addFile(const std::string & name, size_t size, size_t hash_protected_size, const crypto::sha::sSha256Hash& hash)
 {
 	mFileList.addElement({ name, 0, size, hash_protected_size, hash });
 }
 
-size_t nx::PfsHeader::getFileEntrySize(FsType fs_type)
+size_t nn::hac::PfsHeader::getFileEntrySize(FsType fs_type)
 {
 	size_t size = 0;
 	switch(fs_type)
@@ -244,7 +244,7 @@ size_t nx::PfsHeader::getFileEntrySize(FsType fs_type)
 	return size;
 }
 
-void nx::PfsHeader::calculateOffsets(size_t data_offset)
+void nn::hac::PfsHeader::calculateOffsets(size_t data_offset)
 {
 	for (size_t i = 0; i < mFileList.size(); i++)
 	{

lib/libhac/source/ServiceAccessControlBinary.cpp

@@ -1,32 +1,32 @@
-#include <nx/ServiceAccessControlBinary.h>
+#include <nn/hac/ServiceAccessControlBinary.h>
 
-nx::ServiceAccessControlBinary::ServiceAccessControlBinary()
+nn::hac::ServiceAccessControlBinary::ServiceAccessControlBinary()
 {
 	clear();
 }
 
-nx::ServiceAccessControlBinary::ServiceAccessControlBinary(const ServiceAccessControlBinary & other)
+nn::hac::ServiceAccessControlBinary::ServiceAccessControlBinary(const ServiceAccessControlBinary & other)
 {
 	*this = other;
 }
 
-void nx::ServiceAccessControlBinary::operator=(const ServiceAccessControlBinary & other)
+void nn::hac::ServiceAccessControlBinary::operator=(const ServiceAccessControlBinary & other)
 {
 	mRawBinary = other.mRawBinary;
 	mServices = other.mServices;
 }
 
-bool nx::ServiceAccessControlBinary::operator==(const ServiceAccessControlBinary & other) const
+bool nn::hac::ServiceAccessControlBinary::operator==(const ServiceAccessControlBinary & other) const
 {
 	return (mServices == other.mServices);
 }
 
-bool nx::ServiceAccessControlBinary::operator!=(const ServiceAccessControlBinary & other) const
+bool nn::hac::ServiceAccessControlBinary::operator!=(const ServiceAccessControlBinary & other) const
 {
 	return !(*this == other);
 }
 
-void nx::ServiceAccessControlBinary::toBytes()
+void nn::hac::ServiceAccessControlBinary::toBytes()
 {
 	size_t totalSize = 0;
 	for (size_t i = 0; i < mServices.size(); i++)
@@ -42,7 +42,7 @@ void nx::ServiceAccessControlBinary::toBytes()
 	}
 }
 
-void nx::ServiceAccessControlBinary::fromBytes(const byte_t* data, size_t len)
+void nn::hac::ServiceAccessControlBinary::fromBytes(const byte_t* data, size_t len)
 {
 	clear();
 	mRawBinary.alloc(len);
@@ -56,23 +56,23 @@ void nx::ServiceAccessControlBinary::fromBytes(const byte_t* data, size_t len)
 	}
 }
 
-const fnd::Vec<byte_t>& nx::ServiceAccessControlBinary::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::ServiceAccessControlBinary::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::ServiceAccessControlBinary::clear()
+void nn::hac::ServiceAccessControlBinary::clear()
 {
 	mRawBinary.clear();
 	mServices.clear();
 }
 
-const fnd::List<nx::ServiceAccessControlEntry>& nx::ServiceAccessControlBinary::getServiceList() const
+const fnd::List<nn::hac::ServiceAccessControlEntry>& nn::hac::ServiceAccessControlBinary::getServiceList() const
 {
 	return mServices;
 }
 
-void nx::ServiceAccessControlBinary::addService(const ServiceAccessControlEntry& service)
+void nn::hac::ServiceAccessControlBinary::addService(const ServiceAccessControlEntry& service)
 {
 	mServices.addElement(service);
 }

lib/libhac/source/ServiceAccessControlEntry.cpp

@@ -1,23 +1,23 @@
-#include <nx/ServiceAccessControlEntry.h>
+#include <nn/hac/ServiceAccessControlEntry.h>
 
-nx::ServiceAccessControlEntry::ServiceAccessControlEntry()
+nn::hac::ServiceAccessControlEntry::ServiceAccessControlEntry()
 {
 	clear();
 }
 
-nx::ServiceAccessControlEntry::ServiceAccessControlEntry(const std::string & name, bool isServer) :
+nn::hac::ServiceAccessControlEntry::ServiceAccessControlEntry(const std::string & name, bool isServer) :
 	mIsServer(isServer),
 	mName(name)
 {
 	toBytes();
 }
 
-nx::ServiceAccessControlEntry::ServiceAccessControlEntry(const ServiceAccessControlEntry & other)
+nn::hac::ServiceAccessControlEntry::ServiceAccessControlEntry(const ServiceAccessControlEntry & other)
 {
 	*this = other;
 }
 
-void nx::ServiceAccessControlEntry::operator=(const ServiceAccessControlEntry & other)
+void nn::hac::ServiceAccessControlEntry::operator=(const ServiceAccessControlEntry & other)
 {
 	if (other.getBytes().size())
 	{
@@ -31,19 +31,19 @@ void nx::ServiceAccessControlEntry::operator=(const ServiceAccessControlEntry &
 	}
 }
 
-bool nx::ServiceAccessControlEntry::operator==(const ServiceAccessControlEntry & other) const
+bool nn::hac::ServiceAccessControlEntry::operator==(const ServiceAccessControlEntry & other) const
 {
 	return (mIsServer == other.mIsServer) \
 		&& (mName == other.mName);
 }
 
-bool nx::ServiceAccessControlEntry::operator!=(const ServiceAccessControlEntry & other) const
+bool nn::hac::ServiceAccessControlEntry::operator!=(const ServiceAccessControlEntry & other) const
 {
 	return !(*this == other);
 }
 
 
-void nx::ServiceAccessControlEntry::toBytes()
+void nn::hac::ServiceAccessControlEntry::toBytes()
 {
 	try {
 		mRawBinary.alloc(mName.size() + 1);
@@ -68,7 +68,7 @@ void nx::ServiceAccessControlEntry::toBytes()
 	memcpy(mRawBinary.data() + 1, mName.c_str(), mName.length());
 }
 
-void nx::ServiceAccessControlEntry::fromBytes(const byte_t* data, size_t len)
+void nn::hac::ServiceAccessControlEntry::fromBytes(const byte_t* data, size_t len)
 {
 	bool isServer = (data[0] & SAC_IS_SERVER) == SAC_IS_SERVER;
 	size_t nameLen = (data[0] & SAC_NAME_LEN_MASK) + 1; // bug?
@@ -94,33 +94,33 @@ void nx::ServiceAccessControlEntry::fromBytes(const byte_t* data, size_t len)
 	mName = std::string((const char*)(mRawBinary.data() + 1), nameLen);
 }
 
-const fnd::Vec<byte_t>& nx::ServiceAccessControlEntry::getBytes() const
+const fnd::Vec<byte_t>& nn::hac::ServiceAccessControlEntry::getBytes() const
 {
 	return mRawBinary;
 }
 
-void nx::ServiceAccessControlEntry::clear()
+void nn::hac::ServiceAccessControlEntry::clear()
 {
 	mIsServer = false;
 	mName.clear();
 }
 
-bool nx::ServiceAccessControlEntry::isServer() const
+bool nn::hac::ServiceAccessControlEntry::isServer() const
 {
 	return mIsServer;
 }
 
-void nx::ServiceAccessControlEntry::setIsServer(bool isServer)
+void nn::hac::ServiceAccessControlEntry::setIsServer(bool isServer)
 {
 	mIsServer = isServer;
 }
 
-const std::string & nx::ServiceAccessControlEntry::getName() const
+const std::string & nn::hac::ServiceAccessControlEntry::getName() const
 {
 	return mName;
 }
 
-void nx::ServiceAccessControlEntry::setName(const std::string & name)
+void nn::hac::ServiceAccessControlEntry::setName(const std::string & name)
 {
 	if (name.length() > kMaxServiceNameLen)
 	{

lib/libhac/source/SystemCallEntry.cpp

@@ -1,6 +1,6 @@
-#include <nx/SystemCallEntry.h>
+#include <nn/hac/SystemCallEntry.h>
 
-nx::SystemCallEntry::SystemCallEntry() :
+nn::hac::SystemCallEntry::SystemCallEntry() :
 	mCap(kCapId),
 	mSystemCallUpper(0),
 	mSystemCallLower(0)
@@ -8,7 +8,7 @@ nx::SystemCallEntry::SystemCallEntry() :
 
 }
 
-nx::SystemCallEntry::SystemCallEntry(const KernelCapabilityEntry & kernel_cap) :
+nn::hac::SystemCallEntry::SystemCallEntry(const KernelCapabilityEntry & kernel_cap) :
 	mCap(kCapId),
 	mSystemCallUpper(0),
 	mSystemCallLower(0)
@@ -16,7 +16,7 @@ nx::SystemCallEntry::SystemCallEntry(const KernelCapabilityEntry & kernel_cap) :
 	setKernelCapability(kernel_cap);
 }
 
-nx::SystemCallEntry::SystemCallEntry(uint32_t upper_bits, uint32_t lower_bits) :
+nn::hac::SystemCallEntry::SystemCallEntry(uint32_t upper_bits, uint32_t lower_bits) :
 	mCap(kCapId),
 	mSystemCallUpper(0),
 	mSystemCallLower(0)
@@ -25,30 +25,30 @@ nx::SystemCallEntry::SystemCallEntry(uint32_t upper_bits, uint32_t lower_bits) :
 	setSystemCallLowerBits(lower_bits);
 }
 
-void nx::SystemCallEntry::operator=(const SystemCallEntry& other)
+void nn::hac::SystemCallEntry::operator=(const SystemCallEntry& other)
 {
 	mSystemCallUpper = other.mSystemCallUpper;
 	mSystemCallLower = other.mSystemCallLower;
 	updateCapField();
 }
 
-bool nx::SystemCallEntry::operator==(const SystemCallEntry& other) const
+bool nn::hac::SystemCallEntry::operator==(const SystemCallEntry& other) const
 {
 	return (mSystemCallUpper == other.mSystemCallUpper) \
 		&& (mSystemCallLower == other.mSystemCallLower);
 }
 
-bool nx::SystemCallEntry::operator!=(const SystemCallEntry& other) const
+bool nn::hac::SystemCallEntry::operator!=(const SystemCallEntry& other) const
 {
 	return !(*this == other);
 }
 
-const nx::KernelCapabilityEntry & nx::SystemCallEntry::getKernelCapability() const
+const nn::hac::KernelCapabilityEntry & nn::hac::SystemCallEntry::getKernelCapability() const
 {
 	return mCap;
 }
 
-void nx::SystemCallEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
+void nn::hac::SystemCallEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
 {
 	if (kernel_cap.getType() != kCapId)
 	{
@@ -59,12 +59,12 @@ void nx::SystemCallEntry::setKernelCapability(const KernelCapabilityEntry & kern
 	processCapField();
 }
 
-uint32_t nx::SystemCallEntry::getSystemCallUpperBits() const
+uint32_t nn::hac::SystemCallEntry::getSystemCallUpperBits() const
 {
 	return mSystemCallUpper;
 }
 
-void nx::SystemCallEntry::setSystemCallUpperBits(uint32_t upper_bits)
+void nn::hac::SystemCallEntry::setSystemCallUpperBits(uint32_t upper_bits)
 {
 	if (upper_bits > kSysCallUpperMax)
 	{
@@ -75,12 +75,12 @@ void nx::SystemCallEntry::setSystemCallUpperBits(uint32_t upper_bits)
 	updateCapField();
 }
 
-uint32_t nx::SystemCallEntry::getSystemCallLowerBits() const
+uint32_t nn::hac::SystemCallEntry::getSystemCallLowerBits() const
 {
 	return mSystemCallLower;
 }
 
-void nx::SystemCallEntry::setSystemCallLowerBits(uint32_t lower_bits)
+void nn::hac::SystemCallEntry::setSystemCallLowerBits(uint32_t lower_bits)
 {
 	if (lower_bits > kSysCallLowerMax)
 	{

lib/libhac/source/SystemCallHandler.cpp

@@ -1,29 +1,29 @@
-#include <nx/SystemCallHandler.h>
+#include <nn/hac/SystemCallHandler.h>
-#include <nx/SystemCallEntry.h>
+#include <nn/hac/SystemCallEntry.h>
 
-nx::SystemCallHandler::SystemCallHandler() :
+nn::hac::SystemCallHandler::SystemCallHandler() :
 	mIsSet(false),
 	mSystemCalls()
 {}
 
-void nx::SystemCallHandler::operator=(const SystemCallHandler & other)
+void nn::hac::SystemCallHandler::operator=(const SystemCallHandler & other)
 {
 	mIsSet = other.mIsSet;
 	mSystemCalls = other.mSystemCalls;
 }
 
-bool nx::SystemCallHandler::operator==(const SystemCallHandler & other) const
+bool nn::hac::SystemCallHandler::operator==(const SystemCallHandler & other) const
 {
 	return (mIsSet == other.mIsSet) \
 		&& (mSystemCalls == other.mSystemCalls);
 }
 
-bool nx::SystemCallHandler::operator!=(const SystemCallHandler & other) const
+bool nn::hac::SystemCallHandler::operator!=(const SystemCallHandler & other) const
 {
 	return !(*this == other);
 }
 
-void nx::SystemCallHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
+void nn::hac::SystemCallHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
 {
 	if (caps.size() == 0)
 		return;
@@ -49,7 +49,7 @@ void nx::SystemCallHandler::importKernelCapabilityList(const fnd::List<KernelCap
 	mIsSet = true;
 }
 
-void nx::SystemCallHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
+void nn::hac::SystemCallHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
 {
 	if (isSet() == false)
 		return;
@@ -80,23 +80,23 @@ void nx::SystemCallHandler::exportKernelCapabilityList(fnd::List<KernelCapabilit
 	}
 }
 
-void nx::SystemCallHandler::clear()
+void nn::hac::SystemCallHandler::clear()
 {
 	mIsSet = false;
 	mSystemCalls.clear();
 }
 
-bool nx::SystemCallHandler::isSet() const
+bool nn::hac::SystemCallHandler::isSet() const
 {
 	return mIsSet;
 }
 
-const fnd::List<uint8_t>& nx::SystemCallHandler::getSystemCalls() const
+const fnd::List<uint8_t>& nn::hac::SystemCallHandler::getSystemCalls() const
 {
 	return mSystemCalls;
 }
 
-void nx::SystemCallHandler::setSystemCallList(const fnd::List<uint8_t>& calls)
+void nn::hac::SystemCallHandler::setSystemCallList(const fnd::List<uint8_t>& calls)
 {
 	mSystemCalls.clear();
 	for (size_t i = 0; i < calls.size(); i++)

lib/libhac/source/ThreadInfoEntry.cpp

@@ -1,6 +1,6 @@
-#include <nx/ThreadInfoEntry.h>
+#include <nn/hac/ThreadInfoEntry.h>
 
-nx::ThreadInfoEntry::ThreadInfoEntry() :
+nn::hac::ThreadInfoEntry::ThreadInfoEntry() :
 	mCap(kCapId),
 	mMinPriority(kDefaultPriority),
 	mMaxPriority(kDefaultPriority),
@@ -8,7 +8,7 @@ nx::ThreadInfoEntry::ThreadInfoEntry() :
 	mMaxCpuId(kDefaultCpuId)
 {}
 
-nx::ThreadInfoEntry::ThreadInfoEntry(const KernelCapabilityEntry & kernel_cap) :
+nn::hac::ThreadInfoEntry::ThreadInfoEntry(const KernelCapabilityEntry & kernel_cap) :
 	mCap(kCapId),
 	mMinPriority(kDefaultPriority),
 	mMaxPriority(kDefaultPriority),
@@ -18,7 +18,7 @@ nx::ThreadInfoEntry::ThreadInfoEntry(const KernelCapabilityEntry & kernel_cap) :
 	setKernelCapability(kernel_cap);
 }
 
-nx::ThreadInfoEntry::ThreadInfoEntry(uint8_t min_priority, uint8_t max_priority, uint8_t min_core_number, uint8_t max_core_number) :
+nn::hac::ThreadInfoEntry::ThreadInfoEntry(uint8_t min_priority, uint8_t max_priority, uint8_t min_core_number, uint8_t max_core_number) :
 	mCap(kCapId),
 	mMinPriority(kDefaultPriority),
 	mMaxPriority(kDefaultPriority),
@@ -31,7 +31,7 @@ nx::ThreadInfoEntry::ThreadInfoEntry(uint8_t min_priority, uint8_t max_priority,
 	setMaxCpuId(max_core_number);
 }
 
-void nx::ThreadInfoEntry::operator=(const ThreadInfoEntry& other)
+void nn::hac::ThreadInfoEntry::operator=(const ThreadInfoEntry& other)
 {
 	mMinPriority = other.mMinPriority;
 	mMaxPriority = other.mMaxPriority;
@@ -40,7 +40,7 @@ void nx::ThreadInfoEntry::operator=(const ThreadInfoEntry& other)
 	updateCapField();
 }
 
-bool nx::ThreadInfoEntry::operator==(const ThreadInfoEntry& other) const
+bool nn::hac::ThreadInfoEntry::operator==(const ThreadInfoEntry& other) const
 {
 	return (mMinPriority == other.mMinPriority) \
 		&& (mMaxPriority == other.mMaxPriority) \
@@ -48,17 +48,17 @@ bool nx::ThreadInfoEntry::operator==(const ThreadInfoEntry& other) const
 		&& (mMaxCpuId == other.mMaxCpuId);
 }
 
-bool nx::ThreadInfoEntry::operator!=(const ThreadInfoEntry& other) const
+bool nn::hac::ThreadInfoEntry::operator!=(const ThreadInfoEntry& other) const
 {
 	return !(*this == other);
 }
 
-const nx::KernelCapabilityEntry & nx::ThreadInfoEntry::getKernelCapability() const
+const nn::hac::KernelCapabilityEntry & nn::hac::ThreadInfoEntry::getKernelCapability() const
 {
 	return mCap;
 }
 
-void nx::ThreadInfoEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
+void nn::hac::ThreadInfoEntry::setKernelCapability(const KernelCapabilityEntry & kernel_cap)
 {
 	if (kernel_cap.getType() != kCapId)
 	{
@@ -69,12 +69,12 @@ void nx::ThreadInfoEntry::setKernelCapability(const KernelCapabilityEntry & kern
 	processCapField();
 }
 
-uint8_t nx::ThreadInfoEntry::getMinPriority() const
+uint8_t nn::hac::ThreadInfoEntry::getMinPriority() const
 {
 	return mMinPriority;
 }
 
-void nx::ThreadInfoEntry::setMinPriority(uint8_t priority)
+void nn::hac::ThreadInfoEntry::setMinPriority(uint8_t priority)
 {
 	if (priority > kMaxVal)
 	{
@@ -85,12 +85,12 @@ void nx::ThreadInfoEntry::setMinPriority(uint8_t priority)
 	updateCapField();
 }
 
-uint8_t nx::ThreadInfoEntry::getMaxPriority() const
+uint8_t nn::hac::ThreadInfoEntry::getMaxPriority() const
 {
 	return mMaxPriority;
 }
 
-void nx::ThreadInfoEntry::setMaxPriority(uint8_t priority)
+void nn::hac::ThreadInfoEntry::setMaxPriority(uint8_t priority)
 {
 	if (priority > kMaxVal)
 	{
@@ -101,12 +101,12 @@ void nx::ThreadInfoEntry::setMaxPriority(uint8_t priority)
 	updateCapField();
 }
 
-uint8_t nx::ThreadInfoEntry::getMinCpuId() const
+uint8_t nn::hac::ThreadInfoEntry::getMinCpuId() const
 {
 	return mMinCpuId;
 }
 
-void nx::ThreadInfoEntry::setMinCpuId(uint8_t core_num)
+void nn::hac::ThreadInfoEntry::setMinCpuId(uint8_t core_num)
 {
 	if (core_num > kMaxVal)
 	{
@@ -117,12 +117,12 @@ void nx::ThreadInfoEntry::setMinCpuId(uint8_t core_num)
 	updateCapField();
 }
 
-uint8_t nx::ThreadInfoEntry::getMaxCpuId() const
+uint8_t nn::hac::ThreadInfoEntry::getMaxCpuId() const
 {
 	return mMaxCpuId;
 }
 
-void nx::ThreadInfoEntry::setMaxCpuId(uint8_t core_num)
+void nn::hac::ThreadInfoEntry::setMaxCpuId(uint8_t core_num)
 {
 	if (core_num > kMaxVal)
 	{

lib/libhac/source/ThreadInfoHandler.cpp

@@ -1,28 +1,28 @@
-#include <nx/ThreadInfoHandler.h>
+#include <nn/hac/ThreadInfoHandler.h>
 
-nx::ThreadInfoHandler::ThreadInfoHandler() :
+nn::hac::ThreadInfoHandler::ThreadInfoHandler() :
 	mIsSet(false),
 	mEntry(0,0,0,0)
 {}
 
-void nx::ThreadInfoHandler::operator=(const ThreadInfoHandler & other)
+void nn::hac::ThreadInfoHandler::operator=(const ThreadInfoHandler & other)
 {
 	mIsSet = other.mIsSet;
 	mEntry.setKernelCapability(other.mEntry.getKernelCapability());
 }
 
-bool nx::ThreadInfoHandler::operator==(const ThreadInfoHandler & other) const
+bool nn::hac::ThreadInfoHandler::operator==(const ThreadInfoHandler & other) const
 {
 	return (mIsSet == other.mIsSet) \
 		&& (mEntry.getKernelCapability() == other.mEntry.getKernelCapability());
 }
 
-bool nx::ThreadInfoHandler::operator!=(const ThreadInfoHandler & other) const
+bool nn::hac::ThreadInfoHandler::operator!=(const ThreadInfoHandler & other) const
 {
 	return !(*this == other);
 }
 
-void nx::ThreadInfoHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
+void nn::hac::ThreadInfoHandler::importKernelCapabilityList(const fnd::List<KernelCapabilityEntry>& caps)
 {
 	if (caps.size() > kMaxKernelCapNum)
 	{
@@ -36,7 +36,7 @@ void nx::ThreadInfoHandler::importKernelCapabilityList(const fnd::List<KernelCap
 	mIsSet = true;
 }
 
-void nx::ThreadInfoHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
+void nn::hac::ThreadInfoHandler::exportKernelCapabilityList(fnd::List<KernelCapabilityEntry>& caps) const
 {
 	if (isSet() == false)
 		return;
@@ -44,7 +44,7 @@ void nx::ThreadInfoHandler::exportKernelCapabilityList(fnd::List<KernelCapabilit
 	caps.addElement(mEntry.getKernelCapability());
 }
 
-void nx::ThreadInfoHandler::clear()
+void nn::hac::ThreadInfoHandler::clear()
 {
 	mIsSet = false;
 	mEntry.setMaxPriority(0);
@@ -53,50 +53,50 @@ void nx::ThreadInfoHandler::clear()
 	mEntry.setMinCpuId(0);
 }
 
-bool nx::ThreadInfoHandler::isSet() const
+bool nn::hac::ThreadInfoHandler::isSet() const
 {
 	return mIsSet;
 }
 
-uint8_t nx::ThreadInfoHandler::getMinPriority() const
+uint8_t nn::hac::ThreadInfoHandler::getMinPriority() const
 {
 	return mEntry.getMinPriority();
 }
 
-void nx::ThreadInfoHandler::setMinPriority(uint8_t priority)
+void nn::hac::ThreadInfoHandler::setMinPriority(uint8_t priority)
 {
 	mEntry.setMinPriority(priority);
 	mIsSet = true;
 }
 
-uint8_t nx::ThreadInfoHandler::getMaxPriority() const
+uint8_t nn::hac::ThreadInfoHandler::getMaxPriority() const
 {
 	return mEntry.getMaxPriority();
 }
 
-void nx::ThreadInfoHandler::setMaxPriority(uint8_t priority)
+void nn::hac::ThreadInfoHandler::setMaxPriority(uint8_t priority)
 {
 	mEntry.setMaxPriority(priority);
 	mIsSet = true;
 }
 
-uint8_t nx::ThreadInfoHandler::getMinCpuId() const
+uint8_t nn::hac::ThreadInfoHandler::getMinCpuId() const
 {
 	return mEntry.getMinCpuId();
 }
 
-void nx::ThreadInfoHandler::setMinCpuId(uint8_t core_num)
+void nn::hac::ThreadInfoHandler::setMinCpuId(uint8_t core_num)
 {
 	mEntry.setMinCpuId(core_num);
 	mIsSet = true;
 }
 
-uint8_t nx::ThreadInfoHandler::getMaxCpuId() const
+uint8_t nn::hac::ThreadInfoHandler::getMaxCpuId() const
 {
 	return mEntry.getMaxCpuId();
 }
 
-void nx::ThreadInfoHandler::setMaxCpuId(uint8_t core_num)
+void nn::hac::ThreadInfoHandler::setMaxCpuId(uint8_t core_num)
 {
 	mEntry.setMaxCpuId(core_num);
 	mIsSet = true;