Fixed possible conflicts with LUS

59 files changed, 166 insertions, 158 deletions

diff --git a/TemplateFactory.cpp b/TemplateFactory.cpp
index 811231b..f17e0f3 100644
--- a/TemplateFactory.cpp
+++ b/TemplateFactory.cpp
@@ -35,7 +35,7 @@ ExportResult TypeBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPa
 std::optional<std::shared_ptr<IParsedData>> TypeFactory::parse(std::vector<uint8_t>& buffer, YAML::Node& node) {
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, 0x1000);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     return std::make_shared<TypeData>();
 }
diff --git a/lib/binarytools/BinaryReader.cpp b/lib/binarytools/BinaryReader.cpp
index 4afeb17..622ed21 100644
--- a/lib/binarytools/BinaryReader.cpp
+++ b/lib/binarytools/BinaryReader.cpp
@@ -24,11 +24,11 @@ void LUS::BinaryReader::Close() {
     mStream->Close();
 }
 
-void LUS::BinaryReader::SetEndianness(Endianness endianness) {
+void LUS::BinaryReader::SetEndianness(Torch::Endianness endianness) {
     this->mEndianness = endianness;
 }
 
-LUS::Endianness LUS::BinaryReader::GetEndianness() const {
+Torch::Endianness LUS::BinaryReader::GetEndianness() const {
     return mEndianness;
 }
 
@@ -59,7 +59,7 @@ int8_t LUS::BinaryReader::ReadInt8() {
 int16_t LUS::BinaryReader::ReadInt16() {
     int16_t result = 0;
     mStream->Read((char*)&result, sizeof(int16_t));
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP16(result);
     }
     return result;
@@ -70,7 +70,7 @@ int32_t LUS::BinaryReader::ReadInt32() {
 
     mStream->Read((char*)&result, sizeof(int32_t));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP32(result);
     }
 
@@ -86,7 +86,7 @@ uint16_t LUS::BinaryReader::ReadUInt16() {
 
     mStream->Read((char*)&result, sizeof(uint16_t));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP16(result);
     }
 
@@ -98,7 +98,7 @@ uint32_t LUS::BinaryReader::ReadUInt32() {
 
     mStream->Read((char*)&result, sizeof(uint32_t));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP32(result);
     }
 
@@ -110,7 +110,7 @@ uint64_t LUS::BinaryReader::ReadUInt64() {
 
     mStream->Read((char*)&result, sizeof(uint64_t));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP64(result);
     }
 
@@ -121,7 +121,7 @@ unsigned short LUS::BinaryReader::ReadUShort() {
     unsigned short result = 0;
     mStream->Read((char*)&result, sizeof(unsigned short));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP16(result);
     }
 
@@ -132,7 +132,7 @@ short LUS::BinaryReader::ReadShort() {
     short result = 0;
     mStream->Read((char*)&result, sizeof(short));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP16(result);
     }
 
@@ -144,7 +144,7 @@ float LUS::BinaryReader::ReadFloat() {
 
     mStream->Read((char*)&result, sizeof(float));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         float tmp;
         char* dst = (char*)&tmp;
         char* src = (char*)&result;
@@ -167,7 +167,7 @@ double LUS::BinaryReader::ReadDouble() {
 
     mStream->Read((char*)&result, sizeof(double));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         double tmp;
         char* dst = (char*)&tmp;
         char* src = (char*)&result;
diff --git a/lib/binarytools/BinaryReader.h b/lib/binarytools/BinaryReader.h
index a98742f..304455d 100644
--- a/lib/binarytools/BinaryReader.h
+++ b/lib/binarytools/BinaryReader.h
@@ -3,8 +3,8 @@
 #include <string>
 #include <memory>
 #include <vector>
-#include "endianness.h"
-#include "Stream.h"
+#include "lib/binarytools/endianness.h"
+#include "lib/binarytools/Stream.h"
 
 class BinaryReader;
 
@@ -19,8 +19,8 @@ class BinaryReader {
 
     void Close();
 
-    void SetEndianness(Endianness endianness);
-    Endianness GetEndianness() const;
+    void SetEndianness(Torch::Endianness endianness);
+    Torch::Endianness GetEndianness() const;
 
     void Seek(int32_t offset, SeekOffsetType seekType);
     uint32_t GetBaseAddress();
@@ -47,6 +47,6 @@ class BinaryReader {
 
   protected:
     std::shared_ptr<Stream> mStream;
-    Endianness mEndianness = Endianness::Native;
+    Torch::Endianness mEndianness = Torch::Endianness::Native;
 };
 } // namespace LUS
diff --git a/lib/binarytools/BinaryWriter.cpp b/lib/binarytools/BinaryWriter.cpp
index 4d48a0e..9aa5d6f 100644
--- a/lib/binarytools/BinaryWriter.cpp
+++ b/lib/binarytools/BinaryWriter.cpp
@@ -14,7 +14,7 @@ LUS::BinaryWriter::BinaryWriter(std::shared_ptr<Stream> nStream) {
     mStream = nStream;
 }
 
-void LUS::BinaryWriter::SetEndianness(Endianness endianness) {
+void LUS::BinaryWriter::SetEndianness(Torch::Endianness endianness) {
     this->mEndianness = endianness;
 }
 
@@ -47,7 +47,7 @@ void LUS::BinaryWriter::Write(uint8_t value) {
 }
 
 void LUS::BinaryWriter::Write(int16_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP16(value);
     }
 
@@ -55,7 +55,7 @@ void LUS::BinaryWriter::Write(int16_t value) {
 }
 
 void LUS::BinaryWriter::Write(uint16_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP16(value);
     }
 
@@ -63,7 +63,7 @@ void LUS::BinaryWriter::Write(uint16_t value) {
 }
 
 void LUS::BinaryWriter::Write(int32_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP32(value);
     }
 
@@ -76,7 +76,7 @@ void LUS::BinaryWriter::Write(int32_t valueA, int32_t valueB) {
 }
 
 void LUS::BinaryWriter::Write(uint32_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP32(value);
     }
 
@@ -84,7 +84,7 @@ void LUS::BinaryWriter::Write(uint32_t value) {
 }
 
 void LUS::BinaryWriter::Write(int64_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP64(value);
     }
 
@@ -92,7 +92,7 @@ void LUS::BinaryWriter::Write(int64_t value) {
 }
 
 void LUS::BinaryWriter::Write(uint64_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP64(value);
     }
 
@@ -100,7 +100,7 @@ void LUS::BinaryWriter::Write(uint64_t value) {
 }
 
 void LUS::BinaryWriter::Write(float value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         float tmp;
         char* dst = (char*)&tmp;
         char* src = (char*)&value;
@@ -115,7 +115,7 @@ void LUS::BinaryWriter::Write(float value) {
 }
 
 void LUS::BinaryWriter::Write(double value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         double tmp;
         char* dst = (char*)&tmp;
         char* src = (char*)&value;
diff --git a/lib/binarytools/BinaryWriter.h b/lib/binarytools/BinaryWriter.h
index 28fdd09..089a7f5 100644
--- a/lib/binarytools/BinaryWriter.h
+++ b/lib/binarytools/BinaryWriter.h
@@ -4,8 +4,8 @@
 #include <memory>
 #include <string>
 #include <vector>
-#include "endianness.h"
-#include "Stream.h"
+#include "lib/binarytools/endianness.h"
+#include "lib/binarytools/Stream.h"
 
 namespace LUS {
 class BinaryWriter {
@@ -14,7 +14,7 @@ class BinaryWriter {
     BinaryWriter(Stream* nStream);
     BinaryWriter(std::shared_ptr<Stream> nStream);
 
-    void SetEndianness(Endianness endianness);
+    void SetEndianness(Torch::Endianness endianness);
 
     std::shared_ptr<Stream> GetStream();
     uint64_t GetBaseAddress();
@@ -43,7 +43,7 @@ class BinaryWriter {
 
 protected:
     std::shared_ptr<Stream> mStream;
-    Endianness mEndianness = Endianness::Native;
+    Torch::Endianness mEndianness = Torch::Endianness::Native;
 
 };
 } // namespace LUS
diff --git a/lib/binarytools/endianness.h b/lib/binarytools/endianness.h
index d7a9baa..3a967bb 100644
--- a/lib/binarytools/endianness.h
+++ b/lib/binarytools/endianness.h
@@ -1,8 +1,7 @@
-#ifndef ENDIANESS_H
-#define ENDIANESS_H
+#pragma once
 
 #ifdef __cplusplus
-namespace LUS {
+namespace Torch {
 enum class Endianness {
     Little = 0,
     Big = 1,
@@ -83,6 +82,4 @@ enum class Endianness {
 #define LE16SWAP_CONST(x) (x)
 #define LE32SWAP_CONST(x) (x)
 #define LE64SWAP_CONST(x) (x)
-#endif
-
-#endif
+#endif
\ No newline at end of file
diff --git a/src/Companion.cpp b/src/Companion.cpp
index d5d4801..374ee85 100644
--- a/src/Companion.cpp
+++ b/src/Companion.cpp
@@ -958,9 +958,11 @@ void Companion::Process() {
     bool isDirectoryMode = config["mode"] && config["mode"].as<std::string>() == "directory";
 
     if(!isDirectoryMode) {
-        std::ifstream input( this->gRomPath, std::ios::binary );
-        this->gRomData = std::vector<uint8_t>( std::istreambuf_iterator( input ), {} );
-        input.close();
+        if(this->gRomPath.has_value()){
+            std::ifstream input( this->gRomPath.value(), std::ios::binary );
+            this->gRomData = std::vector<uint8_t>( std::istreambuf_iterator( input ), {} );
+            input.close();
+        }
 
         this->gCartridge = std::make_shared<N64::Cartridge>(this->gRomData);
         this->gCartridge->Initialize();
@@ -1103,7 +1105,6 @@ void Companion::Process() {
     SPDLOG_INFO("Starting Torch...");
 
     if(this->gConfig.parseMode == ParseMode::Default) {
-        SPDLOG_INFO("ROM: {}", this->gRomPath);
         SPDLOG_INFO("Game: {}", this->gCartridge->GetGameTitle());
         SPDLOG_INFO("CRC: {}", this->gCartridge->GetCRC());
         SPDLOG_INFO("Version: {}", this->gCartridge->GetVersion());
@@ -1120,8 +1121,8 @@ void Companion::Process() {
     this->gCurrentWrapper = wrapper;
 
     auto vWriter = LUS::BinaryWriter();
-    vWriter.SetEndianness(LUS::Endianness::Big);
-    vWriter.Write(static_cast<uint8_t>(LUS::Endianness::Big));
+    vWriter.SetEndianness(Torch::Endianness::Big);
+    vWriter.Write(static_cast<uint8_t>(Torch::Endianness::Big));
 
     if(this->gConfig.parseMode == ParseMode::Default) {
         vWriter.Write(this->gCartridge->GetCRC());
@@ -1261,7 +1262,7 @@ std::optional<std::shared_ptr<BaseFactory>> Companion::GetFactory(const std::str
 CompressionType Companion::GetCompressionType(std::vector<uint8_t>& buffer, const uint32_t offset) {
     if (offset) {
         LUS::BinaryReader reader((char*) buffer.data() + offset, sizeof(uint32_t));
-        reader.SetEndianness(LUS::Endianness::Big);
+        reader.SetEndianness(Torch::Endianness::Big);
 
         const std::string header = reader.ReadCString();
 
diff --git a/src/Companion.h b/src/Companion.h
index 7d287b2..e99719f 100644
--- a/src/Companion.h
+++ b/src/Companion.h
@@ -103,7 +103,15 @@ class Companion {
 public:
     static Companion* Instance;
 
-    explicit Companion(std::filesystem::path rom, const bool otr, const bool debug, const bool modding = false) : gRomPath(std::move(rom)), gCartridge(nullptr) {
+    explicit Companion(std::filesystem::path rom, const bool otr, const bool debug, const bool modding = false) : gCartridge(nullptr) {
+        this->gRomPath = rom;
+        this->gConfig.otrMode = otr;
+        this->gConfig.debug = debug;
+        this->gConfig.modding = modding;
+    }
+
+    explicit Companion(std::vector<uint8_t> rom, const bool otr, const bool debug, const bool modding = false) : gCartridge(nullptr) {
+        this->gRomData = rom;
         this->gConfig.otrMode = otr;
         this->gConfig.debug = debug;
         this->gConfig.modding = modding;
@@ -160,7 +168,7 @@ private:
     std::string gCurrentHash;
     std::string gAssetPath;
     std::vector<uint8_t> gRomData;
-    std::filesystem::path gRomPath;
+    std::optional<std::filesystem::path> gRomPath;
     bool gNodeForceProcessing = false;
     bool gIndividualIncludes = false;
     YAML::Node gHashNode;
diff --git a/src/audio/AudioManager.cpp b/src/audio/AudioManager.cpp
index 686403d..c168a39 100644
--- a/src/audio/AudioManager.cpp
+++ b/src/audio/AudioManager.cpp
@@ -70,7 +70,7 @@ void Bank::print() const {
 std::vector<Entry> AudioManager::parse_seq_file(std::vector<uint8_t>& buffer, uint32_t offset, bool isCTL){
     std::vector<Entry> entries;
     LUS::BinaryReader reader((char*) buffer.data(), buffer.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     reader.Seek(offset, LUS::SeekOffsetType::Start);
 
     uint16_t magic = reader.ReadUInt16();
@@ -100,7 +100,7 @@ std::vector<Entry> AudioManager::parse_seq_file(std::vector<uint8_t>& buffer, ui
 
 CTLHeader AudioManager::parse_ctl_header(std::vector<uint8_t>& data){
     LUS::BinaryReader reader((char*) data.data(), data.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     CTLHeader header = { reader.ReadUInt32(), reader.ReadUInt32(), reader.ReadUInt32() };
 
@@ -268,7 +268,7 @@ Bank AudioManager::parse_ctl(CTLHeader header, std::vector<uint8_t> data, Sample
 
 std::optional<AudioBankSound> AudioManager::parse_sound(std::vector<uint8_t> data) {
     LUS::BinaryReader reader((char*) data.data(), data.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     uint32_t addr = reader.ReadUInt32();
     float tuning = reader.ReadFloat();
@@ -286,7 +286,7 @@ std::optional<AudioBankSound> AudioManager::parse_sound(std::vector<uint8_t> dat
 
 Drum AudioManager::parse_drum(std::vector<uint8_t>& data, uint32_t addr) {
     LUS::BinaryReader reader((char*) data.data(), data.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::string name = gen_name("drum");
 
     uint8_t releaseRate = reader.ReadInt8();
@@ -331,7 +331,7 @@ Instrument AudioManager::parse_inst(std::vector<uint8_t>& data, uint32_t addr) {
 
 AdpcmLoop AudioManager::parse_loop(uint32_t addr, std::vector<uint8_t>& bankData){
     LUS::BinaryReader reader((char*) bankData.data(), bankData.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     reader.Seek(addr, LUS::SeekOffsetType::Start);
 
     std::optional<std::vector<int16_t>> state = std::nullopt;
@@ -352,7 +352,7 @@ AdpcmLoop AudioManager::parse_loop(uint32_t addr, std::vector<uint8_t>& bankData
 
 AdpcmBook AudioManager::parse_book(uint32_t addr, std::vector<uint8_t>& bankData){
     LUS::BinaryReader reader((char*) bankData.data(), bankData.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     reader.Seek(addr, LUS::SeekOffsetType::Start);
 
     int32_t order = reader.ReadInt32();
@@ -375,7 +375,7 @@ AdpcmBook AudioManager::parse_book(uint32_t addr, std::vector<uint8_t>& bankData
 
 AudioBankSample* AudioManager::parse_sample(std::vector<uint8_t>& data, std::vector<uint8_t>& bankData, SampleBank* sampleBank){
     LUS::BinaryReader reader((char*) data.data(), data.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     uint32_t zero = reader.ReadUInt32();
     uint32_t addr = reader.ReadUInt32();
@@ -397,7 +397,7 @@ AudioBankSample* AudioManager::parse_sample(std::vector<uint8_t>& data, std::vec
 std::vector<AdsrEnvelope> AudioManager::parse_envelope(uint32_t addr, std::vector<uint8_t>& dataBank){
     std::vector<AdsrEnvelope> entries;
     LUS::BinaryReader reader((char*) dataBank.data(), dataBank.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     while(true){
         reader.Seek(addr, LUS::SeekOffsetType::Start);
@@ -516,12 +516,12 @@ void serialize_f80(double num, LUS::BinaryWriter &writer) {
     { \
     out.Write((uint32_t) BSWAP32(section)); \
     LUS::BinaryWriter tmp = LUS::BinaryWriter(); \
-    tmp.SetEndianness(LUS::Endianness::Big);     \
+    tmp.SetEndianness(Torch::Endianness::Big);     \
 
 #define START_CUSTOM_SECTION(section) \
     {                                 \
     LUS::BinaryWriter tmp = LUS::BinaryWriter(); \
-    tmp.SetEndianness(LUS::Endianness::Big);     \
+    tmp.SetEndianness(Torch::Endianness::Big);     \
     out.Write((uint32_t) BSWAP32(AIFC::MagicValues::AAPL)); \
     tmp.Write(AIFC::MagicValues::stoc); \
     tmp.Write(section, false);                 \
diff --git a/src/factories/AssetArrayFactory.cpp b/src/factories/AssetArrayFactory.cpp
index 0e91fec..670f5f7 100644
--- a/src/factories/AssetArrayFactory.cpp
+++ b/src/factories/AssetArrayFactory.cpp
@@ -50,10 +50,10 @@ ExportResult AssetArrayBinaryExporter::Export(std::ostream &write, std::shared_p
     auto writer = LUS::BinaryWriter();
     auto data = std::static_pointer_cast<AssetArrayData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::AssetArray, 0);
+    WriteHeader(writer, Torch::ResourceType::AssetArray, 0);
 
     writer.Write((uint32_t)data->mPtrs.size());
-    
+
     for (auto ptr : data->mPtrs) {
         if (ptr == 0) {
             writer.Write((uint64_t)0);
@@ -81,7 +81,7 @@ std::optional<std::shared_ptr<IParsedData>> AssetArrayFactory::parse(std::vector
     const auto count = GetSafeNode<uint32_t>(node, "count");
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for (uint32_t i = 0; i < count; ++i) {
         auto ptr = reader.ReadUInt32();
diff --git a/src/factories/BankFactory.cpp b/src/factories/BankFactory.cpp
index 0155ae7..6e72c53 100644
--- a/src/factories/BankFactory.cpp
+++ b/src/factories/BankFactory.cpp
@@ -5,7 +5,7 @@ ExportResult BankBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPa
     auto writer = LUS::BinaryWriter();
     auto bank = std::static_pointer_cast<BankData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Bank, 0);
+    WriteHeader(writer, Torch::ResourceType::Bank, 0);
     writer.Write(bank->mBankId);
     writer.Write(static_cast<uint32_t>(bank->mBank.insts.size()));
     for (auto& instrument : bank->mBank.insts) {
diff --git a/src/factories/BaseFactory.cpp b/src/factories/BaseFactory.cpp
index ba84109..b5050ea 100644
--- a/src/factories/BaseFactory.cpp
+++ b/src/factories/BaseFactory.cpp
@@ -1,7 +1,7 @@
 #include "BaseFactory.h"
 
-void BaseExporter::WriteHeader(LUS::BinaryWriter &writer, LUS::ResourceType resType, int32_t version) {
-    writer.Write((int8_t)(LUS::Endianness::Native)); // 0x00 - Endianness
+void BaseExporter::WriteHeader(LUS::BinaryWriter &writer, Torch::ResourceType resType, int32_t version) {
+    writer.Write((int8_t)(Torch::Endianness::Native)); // 0x00 - Endianness
     writer.Write((int8_t)0); // 0x01 - Is Asset Custom
     writer.Write((int8_t)0); // 0x02 -
     writer.Write((int8_t)0); // 0x03
diff --git a/src/factories/BaseFactory.h b/src/factories/BaseFactory.h
index aa41302..c33caf4 100644
--- a/src/factories/BaseFactory.h
+++ b/src/factories/BaseFactory.h
@@ -82,7 +82,7 @@ public:
 class BaseExporter {
 public:
     virtual ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName, YAML::Node& node, std::string* replacement) = 0;
-    static void WriteHeader(LUS::BinaryWriter& write, LUS::ResourceType resType, int32_t version);
+    static void WriteHeader(LUS::BinaryWriter& write, Torch::ResourceType resType, int32_t version);
 };
 
 class BaseFactory {
diff --git a/src/factories/BlobFactory.cpp b/src/factories/BlobFactory.cpp
index 22727e8..97a6cc1 100644
--- a/src/factories/BlobFactory.cpp
+++ b/src/factories/BlobFactory.cpp
@@ -48,7 +48,7 @@ ExportResult BlobBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPa
     auto writer = LUS::BinaryWriter();
     auto data = std::static_pointer_cast<RawBuffer>(raw)->mBuffer;
 
-    WriteHeader(writer, LUS::ResourceType::Blob, 0);
+    WriteHeader(writer, Torch::ResourceType::Blob, 0);
     writer.Write((uint32_t) data.size());
     writer.Write((char*) data.data(), data.size());
     writer.Finish(write);
diff --git a/src/factories/DisplayListFactory.cpp b/src/factories/DisplayListFactory.cpp
index 970b128..4258996 100644
--- a/src/factories/DisplayListFactory.cpp
+++ b/src/factories/DisplayListFactory.cpp
@@ -192,7 +192,7 @@ ExportResult DListBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
     auto cmds = std::static_pointer_cast<DListData>(raw)->mGfxs;
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::DisplayList, 0);
+    WriteHeader(writer, Torch::ResourceType::DisplayList, 0);
 
     while (writer.GetBaseAddress() % 8 != 0)
         writer.Write(static_cast<int8_t>(0xFF));
@@ -385,7 +385,7 @@ std::optional<std::shared_ptr<IParsedData>> DListFactory::parse(std::vector<uint
 
     auto [_, segment] = Decompressor::AutoDecode(node, raw_buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     std::vector<uint32_t> gfxs;
     auto processing = true;
diff --git a/src/factories/FloatFactory.cpp b/src/factories/FloatFactory.cpp
index 5465999..b213499 100644
--- a/src/factories/FloatFactory.cpp
+++ b/src/factories/FloatFactory.cpp
@@ -73,7 +73,7 @@ ExportResult FloatBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
     auto f = std::static_pointer_cast<FloatData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::Float, 0);
+    WriteHeader(writer, Torch::ResourceType::Float, 0);
     writer.Write((uint32_t) f->mFloats.size());
     for(auto fl : f->mFloats) {
         writer.Write(fl);
@@ -89,7 +89,7 @@ std::optional<std::shared_ptr<IParsedData>> FloatFactory::parse(std::vector<uint
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, count * sizeof(float));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<float> floats;
 
     for(size_t i = 0; i < count; i++) {
diff --git a/src/factories/GenericArrayFactory.cpp b/src/factories/GenericArrayFactory.cpp
index c91dbe2..a154ab5 100644
--- a/src/factories/GenericArrayFactory.cpp
+++ b/src/factories/GenericArrayFactory.cpp
@@ -270,8 +270,8 @@ ExportResult ArrayBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
 
     ArrayType arrayType = arrayTypeMap.at(type);
 
-    WriteHeader(writer, LUS::ResourceType::GenericArray, 0);
-    
+    WriteHeader(writer, Torch::ResourceType::GenericArray, 0);
+
     writer.Write(static_cast<uint32_t>(arrayType));
     writer.Write((uint32_t) array->mData.size());
 
@@ -379,7 +379,7 @@ std::optional<std::shared_ptr<IParsedData>> GenericArrayFactory::parse(std::vect
 
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, count * typeSize);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for (int i = 0; i < count; i++) {
         switch (arrayType) {
diff --git a/src/factories/LightsFactory.cpp b/src/factories/LightsFactory.cpp
index 811583b..09e67d3 100644
--- a/src/factories/LightsFactory.cpp
+++ b/src/factories/LightsFactory.cpp
@@ -108,7 +108,7 @@ ExportResult LightsBinaryExporter::Export(std::ostream &write, std::shared_ptr<I
     auto writer = LUS::BinaryWriter();
     auto size = sizeof(light.l) / sizeof(LightRaw);
 
-    WriteHeader(writer, LUS::ResourceType::Lights, 0);
+    WriteHeader(writer, Torch::ResourceType::Lights, 0);
 
     writer.Write(reinterpret_cast<char*>(light.a.l.col), 3);
     writer.Write(reinterpret_cast<char*>(light.a.l.colc), 3);
@@ -130,7 +130,7 @@ std::optional<std::shared_ptr<IParsedData>> LightsFactory::parse(std::vector<uin
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, sizeof(Lights1Raw));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     Lights1Raw lights;
     // Directional light
 
diff --git a/src/factories/MtxFactory.cpp b/src/factories/MtxFactory.cpp
index 169adda..3098fe9 100644
--- a/src/factories/MtxFactory.cpp
+++ b/src/factories/MtxFactory.cpp
@@ -106,7 +106,7 @@ ExportResult MtxBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPar
     auto mtx = std::static_pointer_cast<MtxData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::Matrix, 0);
+    WriteHeader(writer, Torch::ResourceType::Matrix, 0);
     writer.Write((uint32_t) mtx->mMtxs.size());
     for(auto m : mtx->mMtxs) {
         writer.Write(m.mtx[0]);
@@ -137,7 +137,7 @@ std::optional<std::shared_ptr<IParsedData>> MtxFactory::parse(std::vector<uint8_
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, 1 * sizeof(MtxRaw));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<MtxRaw> matrix;
 
     #define FIXTOF(x)      ((float)((x) / 65536.0f))
diff --git a/src/factories/ResourceType.h b/src/factories/ResourceType.h
index e144486..215cac2 100644
--- a/src/factories/ResourceType.h
+++ b/src/factories/ResourceType.h
@@ -1,6 +1,6 @@
 #pragma once
 
-namespace LUS {
+namespace Torch {
 
 enum class ResourceType {
     // Not set
diff --git a/src/factories/SampleFactory.cpp b/src/factories/SampleFactory.cpp
index ec88060..b8bc7fa 100644
--- a/src/factories/SampleFactory.cpp
+++ b/src/factories/SampleFactory.cpp
@@ -4,7 +4,7 @@ ExportResult SampleBinaryExporter::Export(std::ostream &write, std::shared_ptr<I
     auto writer = LUS::BinaryWriter();
     auto sample = std::static_pointer_cast<SampleData>(raw)->mSample;
 
-    WriteHeader(writer, LUS::ResourceType::Sample, 0);
+    WriteHeader(writer, Torch::ResourceType::Sample, 0);
     writer.Write(sample.loop.start);
     writer.Write(sample.loop.end);
     writer.Write(sample.loop.count);
diff --git a/src/factories/SequenceFactory.cpp b/src/factories/SequenceFactory.cpp
index 3a6254a..1090bac 100644
--- a/src/factories/SequenceFactory.cpp
+++ b/src/factories/SequenceFactory.cpp
@@ -4,7 +4,7 @@ ExportResult SequenceBinaryExporter::Export(std::ostream &write, std::shared_ptr
     auto writer = LUS::BinaryWriter();
     const auto sequence = std::static_pointer_cast<SequenceData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Sequence, 0);
+    WriteHeader(writer, Torch::ResourceType::Sequence, 0);
     writer.Write(sequence->mId);
     writer.Write(static_cast<uint32_t>(sequence->mBanks.size()));
     for (auto& bank : sequence->mBanks) {
diff --git a/src/factories/TextureFactory.cpp b/src/factories/TextureFactory.cpp
index 3762ad8..7de095a 100644
--- a/src/factories/TextureFactory.cpp
+++ b/src/factories/TextureFactory.cpp
@@ -220,7 +220,7 @@ ExportResult TextureBinaryExporter::Export(std::ostream &write, std::shared_ptr<
     auto texture = std::static_pointer_cast<TextureData>(raw);
     auto data = texture->mBuffer;
 
-    WriteHeader(writer, LUS::ResourceType::Texture, 0);
+    WriteHeader(writer, Torch::ResourceType::Texture, 0);
 
     if(texture->mFormat.type == TextureType::TLUT) {
         texture->mFormat.type = TextureType::RGBA16bpp;
diff --git a/src/factories/Vec3fFactory.cpp b/src/factories/Vec3fFactory.cpp
index 1bb1c73..c101ca4 100644
--- a/src/factories/Vec3fFactory.cpp
+++ b/src/factories/Vec3fFactory.cpp
@@ -62,7 +62,7 @@ ExportResult Vec3fBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
     auto writer = LUS::BinaryWriter();
     auto vecData = std::static_pointer_cast<Vec3fData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Vec3f, 0);
+    WriteHeader(writer, Torch::ResourceType::Vec3f, 0);
     writer.Write((uint32_t) vecData->mVecs.size());
 
     for(Vec3f v : vecData->mVecs) {
@@ -81,7 +81,7 @@ std::optional<std::shared_ptr<IParsedData>> Vec3fFactory::parse(std::vector<uint
     const auto count = GetSafeNode<int>(node, "count");
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, count * sizeof(Vec3f));
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for(int i = 0; i < count; i++) {
         auto vx = reader.ReadFloat();
diff --git a/src/factories/Vec3sFactory.cpp b/src/factories/Vec3sFactory.cpp
index a7290a4..c868363 100644
--- a/src/factories/Vec3sFactory.cpp
+++ b/src/factories/Vec3sFactory.cpp
@@ -60,7 +60,7 @@ ExportResult Vec3sBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
     auto writer = LUS::BinaryWriter();
     auto vecData = std::static_pointer_cast<Vec3sData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Vec3s, 0);
+    WriteHeader(writer, Torch::ResourceType::Vec3s, 0);
     writer.Write((uint32_t) vecData->mVecs.size());
 
     for(Vec3s v : vecData->mVecs) {
@@ -79,7 +79,7 @@ std::optional<std::shared_ptr<IParsedData>> Vec3sFactory::parse(std::vector<uint
     const auto count = GetSafeNode<int>(node, "count");
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, count * sizeof(Vec3s));
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for(int i = 0; i < count; i++) {
         auto vx = reader.ReadInt16();
diff --git a/src/factories/VtxFactory.cpp b/src/factories/VtxFactory.cpp
index 35f9789..7be50f9 100644
--- a/src/factories/VtxFactory.cpp
+++ b/src/factories/VtxFactory.cpp
@@ -125,7 +125,7 @@ ExportResult VtxBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPar
     auto vtx = std::static_pointer_cast<VtxData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::Vertex, 0);
+    WriteHeader(writer, Torch::ResourceType::Vertex, 0);
     writer.Write((uint32_t) vtx->mVtxs.size());
     for(auto v : vtx->mVtxs) {
         writer.Write(v.ob[0]);
@@ -150,7 +150,7 @@ std::optional<std::shared_ptr<IParsedData>> VtxFactory::parse(std::vector<uint8_
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, count * sizeof(VtxRaw));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<VtxRaw> vertices;
 
     for(size_t i = 0; i < count; i++) {
diff --git a/src/factories/mk64/CourseVtx.cpp b/src/factories/mk64/CourseVtx.cpp
index 118a35d..5dbefbb 100644
--- a/src/factories/mk64/CourseVtx.cpp
+++ b/src/factories/mk64/CourseVtx.cpp
@@ -58,7 +58,7 @@ ExportResult MK64::CourseVtxBinaryExporter::Export(std::ostream &write, std::sha
     auto vtx = std::static_pointer_cast<CourseVtxData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::Vertex, 0);
+    WriteHeader(writer, Torch::ResourceType::Vertex, 0);
     writer.Write((uint32_t) vtx->mVtxs.size());
     for(auto v : vtx->mVtxs) {
         writer.Write(v.ob[0]);
@@ -83,7 +83,7 @@ std::optional<std::shared_ptr<IParsedData>> MK64::CourseVtxFactory::parse(std::v
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, count * sizeof(CourseVtx));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<VtxRaw> vertices;
 
     for(size_t i = 0; i < count; i++) {
diff --git a/src/factories/mk64/DrivingBehaviour.cpp b/src/factories/mk64/DrivingBehaviour.cpp
index 2be093a..85b5ca0 100644
--- a/src/factories/mk64/DrivingBehaviour.cpp
+++ b/src/factories/mk64/DrivingBehaviour.cpp
@@ -62,7 +62,7 @@ ExportResult MK64::DrivingBehaviourBinaryExporter::Export(std::ostream &write, s
     auto bhv = std::static_pointer_cast<DrivingData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::DrivingBehaviour, 0);
+    WriteHeader(writer, Torch::ResourceType::DrivingBehaviour, 0);
     writer.Write((uint32_t) bhv->mBhvs.size());
     for(auto b : bhv->mBhvs) {
         writer.Write(b.waypoint1);
@@ -78,7 +78,7 @@ std::optional<std::shared_ptr<IParsedData>> MK64::DrivingBehaviourFactory::parse
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<BhvRaw> behaviours;
 
     while(1) {
diff --git a/src/factories/mk64/ItemCurve.cpp b/src/factories/mk64/ItemCurve.cpp
index 4fa8e96..017ffb8 100644
--- a/src/factories/mk64/ItemCurve.cpp
+++ b/src/factories/mk64/ItemCurve.cpp
@@ -83,7 +83,7 @@ std::optional<std::shared_ptr<IParsedData>> MK64::ItemCurveFactory::parse(std::v
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, (10 * 10) * sizeof(uint8_t));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<uint8_t> items;
 
     // Each array is size of 10*10.
diff --git a/src/factories/mk64/SpawnData.cpp b/src/factories/mk64/SpawnData.cpp
index 44554ea..8b9f383 100644
--- a/src/factories/mk64/SpawnData.cpp
+++ b/src/factories/mk64/SpawnData.cpp
@@ -48,7 +48,7 @@ ExportResult MK64::SpawnDataBinaryExporter::Export(std::ostream &write, std::sha
     auto spawns = std::static_pointer_cast<SpawnDataData>(raw)->mSpawns;
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::SpawnData, 0);
+    WriteHeader(writer, Torch::ResourceType::SpawnData, 0);
     writer.Write((uint32_t) spawns.size());
     for(auto s : spawns) {
         writer.Write(s.x);
@@ -67,7 +67,7 @@ std::optional<std::shared_ptr<IParsedData>> MK64::SpawnDataFactory::parse(std::v
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, count * sizeof(MK64::ActorSpawnData));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<MK64::ActorSpawnData> spawns;
 
     for(size_t i = 0; i < count; i++) {
diff --git a/src/factories/mk64/TrackSections.cpp b/src/factories/mk64/TrackSections.cpp
index 4d13ed8..a1d1291 100644
--- a/src/factories/mk64/TrackSections.cpp
+++ b/src/factories/mk64/TrackSections.cpp
@@ -53,7 +53,7 @@ ExportResult MK64::TrackSectionsBinaryExporter::Export(std::ostream &write, std:
     auto sections = std::static_pointer_cast<TrackSectionsData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::TrackSection, 0);
+    WriteHeader(writer, Torch::ResourceType::TrackSection, 0);
     writer.Write((uint32_t) sections->mSecs.size());
     for(auto entry : sections->mSecs) {
         writer.Write(entry.addr);
@@ -72,7 +72,7 @@ std::optional<std::shared_ptr<IParsedData>> MK64::TrackSectionsFactory::parse(st
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, count * sizeof(MK64::TrackSections));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<MK64::TrackSections> sections;
 
     for(size_t i = 0; i < count; i++) {
diff --git a/src/factories/mk64/Waypoints.cpp b/src/factories/mk64/Waypoints.cpp
index 6dfae5a..8be7110 100644
--- a/src/factories/mk64/Waypoints.cpp
+++ b/src/factories/mk64/Waypoints.cpp
@@ -49,7 +49,7 @@ ExportResult MK64::WaypointBinaryExporter::Export(std::ostream &write, std::shar
     auto waypoints = std::static_pointer_cast<WaypointData>(raw)->mWaypoints;
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::Waypoints, 0);
+    WriteHeader(writer, Torch::ResourceType::Waypoints, 0);
     writer.Write((uint32_t) waypoints.size());
     for(auto w : waypoints) {
         writer.Write(w.posX);
@@ -68,7 +68,7 @@ std::optional<std::shared_ptr<IParsedData>> MK64::WaypointsFactory::parse(std::v
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, count * sizeof(MK64::TrackWaypoint));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<MK64::TrackWaypoint> waypoints;
 
     for(size_t i = 0; i < count; i++) {
diff --git a/src/factories/sf64/AnimFactory.cpp b/src/factories/sf64/AnimFactory.cpp
index ea7adf2..ff5bc96 100644
--- a/src/factories/sf64/AnimFactory.cpp
+++ b/src/factories/sf64/AnimFactory.cpp
@@ -104,7 +104,7 @@ ExportResult SF64::AnimBinaryExporter::Export(std::ostream &write, std::shared_p
     auto anim = std::static_pointer_cast<SF64::AnimData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::AnimData, 0);
+    WriteHeader(writer, Torch::ResourceType::AnimData, 0);
     writer.Write(anim->mFrameCount);
     writer.Write(anim->mLimbCount);
 
@@ -136,7 +136,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::AnimFactory::parse(std::vector
     auto [_, segment] = Decompressor::AutoDecode(node, buffer, 0xC);
     LUS::BinaryReader reader(segment.data, segment.size);
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     int16_t frameCount = reader.ReadInt16();
     int16_t limbCount = reader.ReadInt16();
     uint32_t dataOffset = reader.ReadUInt32();
@@ -147,7 +147,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::AnimFactory::parse(std::vector
 
     auto [__, keySegment] = Decompressor::AutoDecode(keyNode, buffer, sizeof(SF64::JointKey) * (limbCount + 1));
     LUS::BinaryReader keyReader(keySegment.data, keySegment.size);
-    keyReader.SetEndianness(LUS::Endianness::Big);
+    keyReader.SetEndianness(Torch::Endianness::Big);
 
     for(int i = 0; i <= limbCount; i++) {
         auto xLen = keyReader.ReadUInt16();
@@ -175,7 +175,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::AnimFactory::parse(std::vector
     dataCount = std::max(dataCount, maxIndex + 1);
     auto [___, dataSegment] = Decompressor::AutoDecode(dataNode, buffer, sizeof(uint16_t) * dataCount);
     LUS::BinaryReader dataReader(dataSegment.data, dataSegment.size);
-    dataReader.SetEndianness(LUS::Endianness::Big);
+    dataReader.SetEndianness(Torch::Endianness::Big);
 
     for(int i = 0; i < dataCount; i++) {
         frameData.push_back(dataReader.ReadUInt16());
diff --git a/src/factories/sf64/ColPolyFactory.cpp b/src/factories/sf64/ColPolyFactory.cpp
index 50127fb..36d58f3 100644
--- a/src/factories/sf64/ColPolyFactory.cpp
+++ b/src/factories/sf64/ColPolyFactory.cpp
@@ -67,7 +67,7 @@ ExportResult SF64::ColPolyBinaryExporter::Export(std::ostream &write, std::share
     auto writer = LUS::BinaryWriter();
     auto colpolys = std::static_pointer_cast<SF64::ColPolyData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::ColPoly, 0);
+    WriteHeader(writer, Torch::ResourceType::ColPoly, 0);
 
     writer.Write((uint32_t) colpolys->mPolys.size());
 
@@ -100,7 +100,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::ColPolyFactory::parse(std::vec
     int meshSize = 0;
     auto [_, segment] = Decompressor::AutoDecode(node, buffer, count * sizeof(SF64::CollisionPoly));
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for(int i = 0; i < count; i++) {
         int16_t v0 = reader.ReadInt16();
diff --git a/src/factories/sf64/EnvironmentFactory.cpp b/src/factories/sf64/EnvironmentFactory.cpp
index 14d3e2b..7432114 100644
--- a/src/factories/sf64/EnvironmentFactory.cpp
+++ b/src/factories/sf64/EnvironmentFactory.cpp
@@ -62,7 +62,7 @@ ExportResult SF64::EnvironmentBinaryExporter::Export(std::ostream &write, std::s
     auto writer = LUS::BinaryWriter();
     auto environment = std::static_pointer_cast<SF64::EnvironmentData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Environment, 0);
+    WriteHeader(writer, Torch::ResourceType::Environment, 0);
 
     writer.Write(environment->mType);
     writer.Write(environment->mGround);
@@ -90,7 +90,7 @@ ExportResult SF64::EnvironmentBinaryExporter::Export(std::ostream &write, std::s
 std::optional<std::shared_ptr<IParsedData>> SF64::EnvironmentFactory::parse(std::vector<uint8_t>& buffer, YAML::Node& node) {
     auto [_, segment] = Decompressor::AutoDecode(node, buffer, sizeof(SF64::EnvironmentData));
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     Vec3f lightDir;
     int32_t  type = reader.ReadInt32();
     int32_t  ground = reader.ReadInt32();
diff --git a/src/factories/sf64/HitboxFactory.cpp b/src/factories/sf64/HitboxFactory.cpp
index b019b2f..b6b11a6 100644
--- a/src/factories/sf64/HitboxFactory.cpp
+++ b/src/factories/sf64/HitboxFactory.cpp
@@ -99,7 +99,7 @@ ExportResult SF64::HitboxBinaryExporter::Export(std::ostream &write, std::shared
     auto hitbox = std::static_pointer_cast<SF64::HitboxData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::Hitbox, 0);
+    WriteHeader(writer, Torch::ResourceType::Hitbox, 0);
 
     auto count = hitbox->mData.size();
     writer.Write((uint32_t) count);
@@ -116,7 +116,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::HitboxFactory::parse(std::vect
     std::vector<int> types;
     auto [_, segment] = Decompressor::AutoDecode(node, buffer, 0x10000);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     data.push_back(reader.ReadFloat());
     count = data[0];
diff --git a/src/factories/sf64/MessageFactory.cpp b/src/factories/sf64/MessageFactory.cpp
index 81b167f..b2d94b6 100644
--- a/src/factories/sf64/MessageFactory.cpp
+++ b/src/factories/sf64/MessageFactory.cpp
@@ -110,7 +110,7 @@ ExportResult SF64::MessageBinaryExporter::Export(std::ostream &write, std::share
     auto writer = LUS::BinaryWriter();
     const auto data = std::static_pointer_cast<MessageData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Message, 0);
+    WriteHeader(writer, Torch::ResourceType::Message, 0);
 
     auto count = data->mMessage.size();
     writer.Write(static_cast<uint32_t>(count));
@@ -154,7 +154,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::MessageFactory::parse(std::vec
     std::ostringstream mesgStr;
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     uint16_t c;
     std::string whitespace = "";
diff --git a/src/factories/sf64/MessageLookupFactory.cpp b/src/factories/sf64/MessageLookupFactory.cpp
index 61e329a..043ab42 100644
--- a/src/factories/sf64/MessageLookupFactory.cpp
+++ b/src/factories/sf64/MessageLookupFactory.cpp
@@ -48,7 +48,7 @@ ExportResult SF64::MessageLookupBinaryExporter::Export(std::ostream &write, std:
     auto writer = LUS::BinaryWriter();
     const auto data = std::static_pointer_cast<MessageTable>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::MessageTable, 0);
+    WriteHeader(writer, Torch::ResourceType::MessageTable, 0);
 
     const auto count = data->mTable.size();
     SPDLOG_INFO("Message Count: {}", count);
@@ -76,7 +76,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::MessageLookupFactory::parse(st
 
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     int32_t id = reader.ReadInt32();
     uint32_t ptr = reader.ReadInt32();
diff --git a/src/factories/sf64/ObjInitFactory.cpp b/src/factories/sf64/ObjInitFactory.cpp
index a5c0c1c..366de8a 100644
--- a/src/factories/sf64/ObjInitFactory.cpp
+++ b/src/factories/sf64/ObjInitFactory.cpp
@@ -49,7 +49,7 @@ ExportResult SF64::ObjInitBinaryExporter::Export(std::ostream &write, std::share
     auto writer = LUS::BinaryWriter();
     auto data = std::static_pointer_cast<ObjInitData>(raw)->mObjInit;
 
-    WriteHeader(writer, LUS::ResourceType::ObjectInit, 0);
+    WriteHeader(writer, Torch::ResourceType::ObjectInit, 0);
     auto count = data.size();
     writer.Write((uint32_t) count);
     for(size_t i = 0; i < data.size(); i++) {
@@ -70,7 +70,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::ObjInitFactory::parse(std::vec
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
 
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<ObjectInit> objects;
     bool terminator = false;
 
diff --git a/src/factories/sf64/ScriptFactory.cpp b/src/factories/sf64/ScriptFactory.cpp
index ba61571..49bf3fa 100644
--- a/src/factories/sf64/ScriptFactory.cpp
+++ b/src/factories/sf64/ScriptFactory.cpp
@@ -284,7 +284,7 @@ ExportResult SF64::ScriptBinaryExporter::Export(std::ostream &write, std::shared
         std::ostringstream stream;
 
         auto cmdWriter = LUS::BinaryWriter();
-        WriteHeader(cmdWriter, LUS::ResourceType::ScriptCmd, 0);
+        WriteHeader(cmdWriter, Torch::ResourceType::ScriptCmd, 0);
 
         auto cmdCount = script->mSizeMap.at(ptr) / 2;
         cmdWriter.Write((uint32_t) cmdCount);
@@ -307,7 +307,7 @@ ExportResult SF64::ScriptBinaryExporter::Export(std::ostream &write, std::shared
     }
 
     // Export Script
-    WriteHeader(scriptWriter, LUS::ResourceType::Script, 0);
+    WriteHeader(scriptWriter, Torch::ResourceType::Script, 0);
     auto count = script->mPtrs.size();
     scriptWriter.Write((uint32_t) count);
     for (size_t i = 0; i < script->mPtrs.size(); i++) {
@@ -328,7 +328,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::ScriptFactory::parse(std::vect
     std::map<uint32_t, int> sizeMap;
     auto [_, segment] = Decompressor::AutoDecode(node, buffer, 0x1000);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     auto ptr = reader.ReadUInt32();
 
     while(SEGMENT_NUMBER(ptr) == SEGMENT_NUMBER(offset)) {
@@ -351,7 +351,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::ScriptFactory::parse(std::vect
     scriptNode["offset"] = cmdsStart;
     auto [__, scriptSegment] = Decompressor::AutoDecode(scriptNode, buffer, scriptLen * sizeof(uint16_t));
     LUS::BinaryReader scriptReader(scriptSegment.data, scriptSegment.size);
-    scriptReader.SetEndianness(LUS::Endianness::Big);
+    scriptReader.SetEndianness(Torch::Endianness::Big);
     for(int i = 0; i < scriptLen; i++) {
         scriptCmds.push_back(scriptReader.ReadUInt16());
     }
diff --git a/src/factories/sf64/SkeletonFactory.cpp b/src/factories/sf64/SkeletonFactory.cpp
index cab5482..af10694 100644
--- a/src/factories/sf64/SkeletonFactory.cpp
+++ b/src/factories/sf64/SkeletonFactory.cpp
@@ -110,7 +110,7 @@ ExportResult SF64::SkeletonBinaryExporter::Export(std::ostream &write, std::shar
         std::ostringstream stream;
 
         auto limbWriter = LUS::BinaryWriter();
-        WriteHeader(limbWriter, LUS::ResourceType::Limb, 0);
+        WriteHeader(limbWriter, Torch::ResourceType::Limb, 0);
         bool hasDList = limb.mDList != 0 && (SEGMENT_NUMBER(limb.mDList) == SEGMENT_NUMBER(limb.mAddr));
 
         if(hasDList){
@@ -145,7 +145,7 @@ ExportResult SF64::SkeletonBinaryExporter::Export(std::ostream &write, std::shar
     }
 
     // Export Skeleton
-    WriteHeader(skeletonWriter, LUS::ResourceType::Skeleton, 0);
+    WriteHeader(skeletonWriter, Torch::ResourceType::Skeleton, 0);
     skeletonWriter.Write((uint32_t) limbs.size());
     for (auto &limb : limbs) {
         skeletonWriter.Write(limbDict.at(limb.mAddr));
@@ -159,7 +159,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::SkeletonFactory::parse(std::ve
     std::vector<SF64::LimbData> skeleton;
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, 0x1000);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     auto limbAddr = reader.ReadUInt32();
     auto limbIndex = 0;
 
@@ -170,7 +170,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::SkeletonFactory::parse(std::ve
         limbNode["offset"] = limbAddr;
         DecompressedData limbDataRaw = Decompressor::AutoDecode(limbNode, buffer, 0x20);
         LUS::BinaryReader limbReader(limbDataRaw.segment.data, limbDataRaw.segment.size);
-        limbReader.SetEndianness(LUS::Endianness::Big);
+        limbReader.SetEndianness(Torch::Endianness::Big);
 
         auto dListAddr = limbReader.ReadUInt32();
         trans.x = limbReader.ReadFloat();
diff --git a/src/factories/sf64/TriangleFactory.cpp b/src/factories/sf64/TriangleFactory.cpp
index 515f818..c64d77a 100644
--- a/src/factories/sf64/TriangleFactory.cpp
+++ b/src/factories/sf64/TriangleFactory.cpp
@@ -56,7 +56,7 @@ ExportResult SF64::TriangleBinaryExporter::Export(std::ostream &write, std::shar
     auto writer = LUS::BinaryWriter();
     auto triData = std::static_pointer_cast<TriangleData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Vec3s, 0);
+    WriteHeader(writer, Torch::ResourceType::Vec3s, 0);
     writer.Write((uint32_t) triData->mTris.size());
 
     for(Vec3s tri : triData->mTris) {
@@ -79,7 +79,7 @@ std::optional<std::shared_ptr<IParsedData>> SF64::TriangleFactory::parse(std::ve
     int meshSize = 0;
     auto [_, segment] = Decompressor::AutoDecode(node, buffer, count * sizeof(Vec3s));
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for(int i = 0; i < count; i++) {
         Vec3s tri;
diff --git a/src/factories/sm64/AnimationFactory.cpp b/src/factories/sm64/AnimationFactory.cpp
index 28123b0..1ff1eab 100644
--- a/src/factories/sm64/AnimationFactory.cpp
+++ b/src/factories/sm64/AnimationFactory.cpp
@@ -9,7 +9,7 @@ ExportResult SM64::AnimationBinaryExporter::Export(std::ostream &write, std::sha
     auto writer = LUS::BinaryWriter();
     const auto anim = std::static_pointer_cast<AnimationData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Anim, 0);
+    WriteHeader(writer, Torch::ResourceType::Anim, 0);
     writer.Write(anim->mFlags);
     writer.Write(anim->mAnimYTransDivisor);
     writer.Write(anim->mStartFrame);
@@ -36,7 +36,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::AnimationFactory::parse(std::v
     auto offset = node["offset"];
 
     LUS::BinaryReader header = Decompressor::AutoDecode(node, buffer).GetReader();
-    header.SetEndianness(LUS::Endianness::Big);
+    header.SetEndianness(Torch::Endianness::Big);
 
     auto flags = header.ReadInt16();
     auto animYTransDivisor = header.ReadInt16();
@@ -50,7 +50,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::AnimationFactory::parse(std::v
 
     size_t indexLength = ANIMINDEX_COUNT(unusedBoneCount);
     LUS::BinaryReader indices = Decompressor::AutoDecode(indexAddr, indexLength * sizeof(uint16_t), buffer).GetReader();
-    indices.SetEndianness(LUS::Endianness::Big);
+    indices.SetEndianness(Torch::Endianness::Big);
     std::vector<int16_t> indicesData;
     for (size_t i = 0; i < indexLength; i++) {
         indicesData.push_back(indices.ReadInt16());
@@ -58,7 +58,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::AnimationFactory::parse(std::v
 
     size_t valuesSize = (indexAddr - valuesAddr);
     LUS::BinaryReader values = Decompressor::AutoDecode(valuesAddr, valuesSize, buffer).GetReader();
-    values.SetEndianness(LUS::Endianness::Big);
+    values.SetEndianness(Torch::Endianness::Big);
     std::vector<uint16_t> valuesData;
     for (size_t i = 0; i < valuesSize / sizeof(uint16_t); i++) {
         valuesData.push_back(values.ReadUInt16());
diff --git a/src/factories/sm64/BehaviorScriptFactory.cpp b/src/factories/sm64/BehaviorScriptFactory.cpp
index 6cbcd3e..953b1de 100644
--- a/src/factories/sm64/BehaviorScriptFactory.cpp
+++ b/src/factories/sm64/BehaviorScriptFactory.cpp
@@ -112,7 +112,7 @@ ExportResult SM64::BehaviorScriptBinaryExporter::Export(std::ostream &write, std
     auto writer = LUS::BinaryWriter();
     const auto commands = std::static_pointer_cast<BehaviorScriptData>(raw)->mCommands;
 
-    WriteHeader(writer, LUS::ResourceType::BehaviorScript, 0);
+    WriteHeader(writer, Torch::ResourceType::BehaviorScript, 0);
 
     writer.Write((uint32_t)commands.size());
 
diff --git a/src/factories/sm64/CollisionFactory.cpp b/src/factories/sm64/CollisionFactory.cpp
index 29b4f84..d6e284e 100644
--- a/src/factories/sm64/CollisionFactory.cpp
+++ b/src/factories/sm64/CollisionFactory.cpp
@@ -339,7 +339,7 @@ ExportResult SM64::CollisionBinaryExporter::Export(std::ostream &write, std::sha
     writer.Close();
 
     LUS::BinaryWriter output = LUS::BinaryWriter();
-    WriteHeader(output, LUS::ResourceType::Collision, 0);
+    WriteHeader(output, Torch::ResourceType::Collision, 0);
 
     output.Write(static_cast<uint32_t>(buffer.size()));
     output.Write(buffer.data(), buffer.size());
@@ -357,7 +357,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::CollisionFactory::parse(std::v
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     auto cmd = segment.data;
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     while (processing) {
         int16_t terrainLoadType = reader.ReadInt16();
diff --git a/src/factories/sm64/DialogFactory.cpp b/src/factories/sm64/DialogFactory.cpp
index 5ffa4db..c223dbe 100644
--- a/src/factories/sm64/DialogFactory.cpp
+++ b/src/factories/sm64/DialogFactory.cpp
@@ -6,7 +6,7 @@ ExportResult SM64::DialogBinaryExporter::Export(std::ostream &write, std::shared
     auto writer = LUS::BinaryWriter();
     auto dialog = std::static_pointer_cast<DialogData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::SDialog, 0);
+    WriteHeader(writer, Torch::ResourceType::SDialog, 0);
     writer.Write((uint32_t) dialog->mUnused);
     writer.Write((int8_t) dialog->mLinesPerBox);
     writer.Write((int16_t) dialog->mLeftOffset);
@@ -22,7 +22,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::DialogFactory::parse(std::vect
     auto [root, segment] = Decompressor::AutoDecode(node, buffer);
 
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     // Validate this
     // reader.Seek(mio0, LUS::SeekOffsetType::Start);
 
diff --git a/src/factories/sm64/DictionaryFactory.cpp b/src/factories/sm64/DictionaryFactory.cpp
index 7712c8b..4da939c 100644
--- a/src/factories/sm64/DictionaryFactory.cpp
+++ b/src/factories/sm64/DictionaryFactory.cpp
@@ -6,7 +6,7 @@ ExportResult SM64::DictionaryBinaryExporter::Export(std::ostream &write, std::sh
     auto writer = LUS::BinaryWriter();
     const auto data = std::static_pointer_cast<DictionaryData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Dictionary, 0);
+    WriteHeader(writer, Torch::ResourceType::Dictionary, 0);
 
     writer.Write(static_cast<uint32_t>(data->mDictionary.size()));
     for(auto& [key, value] : data->mDictionary){
diff --git a/src/factories/sm64/GeoLayoutFactory.cpp b/src/factories/sm64/GeoLayoutFactory.cpp
index 4970c22..73eed8e 100644
--- a/src/factories/sm64/GeoLayoutFactory.cpp
+++ b/src/factories/sm64/GeoLayoutFactory.cpp
@@ -248,7 +248,7 @@ ExportResult SM64::GeoBinaryExporter::Export(std::ostream&write, std::shared_ptr
     writer.Close();
 
     LUS::BinaryWriter output = LUS::BinaryWriter();
-    WriteHeader(output, LUS::ResourceType::Blob, 0);
+    WriteHeader(output, Torch::ResourceType::Blob, 0);
 
     output.Write(static_cast<uint32_t>(buffer.size()));
     output.Write(buffer.data(), buffer.size());
diff --git a/src/factories/sm64/LevelScriptFactory.cpp b/src/factories/sm64/LevelScriptFactory.cpp
index 013feb6..dc5e68e 100644
--- a/src/factories/sm64/LevelScriptFactory.cpp
+++ b/src/factories/sm64/LevelScriptFactory.cpp
@@ -126,7 +126,7 @@ ExportResult SM64::LevelScriptBinaryExporter::Export(std::ostream &write, std::s
     auto writer = LUS::BinaryWriter();
     const auto commands = std::static_pointer_cast<LevelScriptData>(raw)->mCommands;
 
-    WriteHeader(writer, LUS::ResourceType::LevelScript, 0);
+    WriteHeader(writer, Torch::ResourceType::LevelScript, 0);
 
     writer.Write((uint32_t)commands.size());
 
@@ -240,7 +240,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::LevelScriptFactory::parse(std:
                 cmd += 0x4 << CMD_SIZE_SHIFT;
                 break;
             }
-            case LevelOpcode::SLEEP: 
+            case LevelOpcode::SLEEP:
             case LevelOpcode::SLEEP_BEFORE_EXIT: {
                 auto frames = cur_level_cmd_s16(0x02);
                 arguments.emplace_back(frames);
@@ -310,8 +310,8 @@ std::optional<std::shared_ptr<IParsedData>> SM64::LevelScriptFactory::parse(std:
                 break;
             }
             case LevelOpcode::SKIP:
-            case LevelOpcode::SKIP_NOP: { 
-                cmd += 0x4 << CMD_SIZE_SHIFT;  
+            case LevelOpcode::SKIP_NOP: {
+                cmd += 0x4 << CMD_SIZE_SHIFT;
                 break;
             }
             case LevelOpcode::CALL:
diff --git a/src/factories/sm64/MacroFactory.cpp b/src/factories/sm64/MacroFactory.cpp
index 26fefb8..a3e5feb 100644
--- a/src/factories/sm64/MacroFactory.cpp
+++ b/src/factories/sm64/MacroFactory.cpp
@@ -60,10 +60,10 @@ ExportResult SM64::MacroBinaryExporter::Export(std::ostream &write, std::shared_
     auto writer = LUS::BinaryWriter();
     auto macro = std::static_pointer_cast<SM64::MacroData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::MacroObject, 0);
+    WriteHeader(writer, Torch::ResourceType::MacroObject, 0);
 
     writer.Write((uint32_t)macro->mMacroData.size());
-    
+
     for (auto &object : macro->mMacroData) {
         writer.Write(static_cast<int16_t>(object.preset));
         writer.Write(object.yaw);
@@ -81,7 +81,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::MacroFactory::parse(std::vecto
     std::vector<MacroObject> macroData;
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     while (true) {
         auto presetYaw = reader.ReadInt16();
diff --git a/src/factories/sm64/MovtexFactory.cpp b/src/factories/sm64/MovtexFactory.cpp
index 75c83b6..4fccddf 100644
--- a/src/factories/sm64/MovtexFactory.cpp
+++ b/src/factories/sm64/MovtexFactory.cpp
@@ -80,7 +80,7 @@ ExportResult SM64::MovtexBinaryExporter::Export(std::ostream &write, std::shared
     auto writer = LUS::BinaryWriter();
     auto movtex = std::static_pointer_cast<SM64::MovtexData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Movtex, 0);
+    WriteHeader(writer, Torch::ResourceType::Movtex, 0);
 
     // May want extra info, but importer should just be mMovtexData with an extra 0 (or 2) at the end
     // if (movtex->mIsQuad) {
@@ -90,7 +90,7 @@ ExportResult SM64::MovtexBinaryExporter::Export(std::ostream &write, std::shared
     //     writer.Write(movtex->mVertexCount);
     //     writer.Write((uint32_t)(movtex->mHasColor ? 1 : 0));
     // }
-    
+
     for (auto datum : movtex->mMovtexData) {
         writer.Write(datum);
     }
@@ -125,7 +125,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::MovtexFactory::parse(std::vect
     }
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     std::vector<int16_t> movtexData;
 
diff --git a/src/factories/sm64/MovtexQuadFactory.cpp b/src/factories/sm64/MovtexQuadFactory.cpp
index 7f8500e..4c38b68 100644
--- a/src/factories/sm64/MovtexQuadFactory.cpp
+++ b/src/factories/sm64/MovtexQuadFactory.cpp
@@ -57,7 +57,7 @@ ExportResult SM64::MovtexQuadBinaryExporter::Export(std::ostream &write, std::sh
     auto writer = LUS::BinaryWriter();
     auto quadData = std::static_pointer_cast<SM64::MovtexQuadData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::MovtexQuad, 0);
+    WriteHeader(writer, Torch::ResourceType::MovtexQuad, 0);
     writer.Write((uint32_t) quadData->mMovtexQuads.size());
 
     for (auto &quad: quadData->mMovtexQuads) {
@@ -87,7 +87,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::MovtexQuadFactory::parse(std::
     const auto count = GetSafeNode<size_t>(node, "count");
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<std::pair<int16_t, uint32_t>> movtexQuads;
 
     for (size_t i = 0; i < count; ++i) {
diff --git a/src/factories/sm64/PaintingFactory.cpp b/src/factories/sm64/PaintingFactory.cpp
index a8979d1..5f3f4a0 100644
--- a/src/factories/sm64/PaintingFactory.cpp
+++ b/src/factories/sm64/PaintingFactory.cpp
@@ -126,7 +126,7 @@ ExportResult SM64::PaintingBinaryExporter::Export(std::ostream &write, std::shar
     auto painting = std::static_pointer_cast<SM64::Painting>(raw);
     uint32_t ptr;
 
-    WriteHeader(writer, LUS::ResourceType::Painting, 0);
+    WriteHeader(writer, Torch::ResourceType::Painting, 0);
 
     writer.Write(painting->id);
     writer.Write(painting->imageCount);
@@ -221,7 +221,7 @@ ExportResult SM64::PaintingBinaryExporter::Export(std::ostream &write, std::shar
 std::optional<std::shared_ptr<IParsedData>> SM64::PaintingFactory::parse(std::vector<uint8_t>& buffer, YAML::Node& node) {
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     auto id = reader.ReadInt16();
     auto imageCount = reader.ReadInt8();
diff --git a/src/factories/sm64/PaintingMapFactory.cpp b/src/factories/sm64/PaintingMapFactory.cpp
index 415322c..7428927 100644
--- a/src/factories/sm64/PaintingMapFactory.cpp
+++ b/src/factories/sm64/PaintingMapFactory.cpp
@@ -53,10 +53,10 @@ ExportResult SM64::PaintingMapBinaryExporter::Export(std::ostream &write, std::s
     auto writer = LUS::BinaryWriter();
     auto paintingData = std::static_pointer_cast<SM64::PaintingData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::PaintingData, 0);
+    WriteHeader(writer, Torch::ResourceType::PaintingData, 0);
 
     writer.Write((int16_t)paintingData->mPaintingMappings.size());
-    
+
     for (auto &mapping : paintingData->mPaintingMappings) {
         writer.Write(mapping.vtxId);
         writer.Write(mapping.texX);
@@ -80,7 +80,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::PaintingMapFactory::parse(std:
     std::vector<Vec3s> paintingGroups;
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     auto mappingsSize = reader.ReadInt16();
 
diff --git a/src/factories/sm64/TextFactory.cpp b/src/factories/sm64/TextFactory.cpp
index c0f9bff..2b058dc 100644
--- a/src/factories/sm64/TextFactory.cpp
+++ b/src/factories/sm64/TextFactory.cpp
@@ -5,7 +5,7 @@ ExportResult SM64::TextBinaryExporter::Export(std::ostream &write, std::shared_p
     auto writer = LUS::BinaryWriter();
     auto data = std::static_pointer_cast<RawBuffer>(raw)->mBuffer;
 
-    WriteHeader(writer, LUS::ResourceType::Blob, 0);
+    WriteHeader(writer, Torch::ResourceType::Blob, 0);
     writer.Write((uint32_t) data.size());
     writer.Write((char*) data.data(), data.size());
     writer.Finish(write);
diff --git a/src/factories/sm64/TrajectoryFactory.cpp b/src/factories/sm64/TrajectoryFactory.cpp
index 52d7ce1..a103f79 100644
--- a/src/factories/sm64/TrajectoryFactory.cpp
+++ b/src/factories/sm64/TrajectoryFactory.cpp
@@ -45,10 +45,10 @@ ExportResult SM64::TrajectoryBinaryExporter::Export(std::ostream &write, std::sh
     auto writer = LUS::BinaryWriter();
     auto trajectoryData = std::static_pointer_cast<SM64::TrajectoryData>(raw)->mTrajectoryData;
 
-    WriteHeader(writer, LUS::ResourceType::Trajectory, 0);
+    WriteHeader(writer, Torch::ResourceType::Trajectory, 0);
 
     writer.Write((uint32_t)trajectoryData.size());
-    
+
     for (auto &trajectory : trajectoryData) {
         writer.Write(trajectory.trajId);
         writer.Write(trajectory.posX);
@@ -64,7 +64,7 @@ std::optional<std::shared_ptr<IParsedData>> SM64::TrajectoryFactory::parse(std::
     std::vector<Trajectory> trajectoryData;
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     while (true) {
         auto trajId = reader.ReadInt16();
diff --git a/src/factories/sm64/WaterDropletFactory.cpp b/src/factories/sm64/WaterDropletFactory.cpp
index ac3d6a2..a6b2d41 100644
--- a/src/factories/sm64/WaterDropletFactory.cpp
+++ b/src/factories/sm64/WaterDropletFactory.cpp
@@ -116,7 +116,7 @@ ExportResult SM64::WaterDropletBinaryExporter::Export(std::ostream &write, std::
     auto writer = LUS::BinaryWriter();
     auto waterDropletData = std::static_pointer_cast<SM64::WaterDropletData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::WaterDroplet, 0);
+    WriteHeader(writer, Torch::ResourceType::WaterDroplet, 0);
 
     writer.Write(waterDropletData->flags);
     writer.Write(waterDropletData->model);
@@ -145,7 +145,7 @@ ExportResult SM64::WaterDropletBinaryExporter::Export(std::ostream &write, std::
 std::optional<std::shared_ptr<IParsedData>> SM64::WaterDropletFactory::parse(std::vector<uint8_t>& buffer, YAML::Node& node) {
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     auto flags = reader.ReadInt16();
     auto model = reader.ReadInt16();
diff --git a/src/n64/Cartridge.cpp b/src/n64/Cartridge.cpp
index f725f86..3580d11 100644
--- a/src/n64/Cartridge.cpp
+++ b/src/n64/Cartridge.cpp
@@ -5,7 +5,7 @@
 
 void N64::Cartridge::Initialize() {
     LUS::BinaryReader reader((char*) this->gRomData.data(), this->gRomData.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     reader.Seek(0x10, LUS::SeekOffsetType::Start);
     this->gRomCRC = BSWAP32(reader.ReadUInt32());
     reader.Seek(0x20, LUS::SeekOffsetType::Start);
diff --git a/src/n64/Cartridge.h b/src/n64/Cartridge.h
index 82dd5b1..4477a59 100644
--- a/src/n64/Cartridge.h
+++ b/src/n64/Cartridge.h
@@ -14,8 +14,10 @@ enum class CountryCode {
 
 class Cartridge {
 public:
-    explicit Cartridge(const std::vector<uint8_t>& romData) : gRomData(romData), gCountryCode(CountryCode::Unknown), gVersion(0), gGameTitle("Unknown") {}
-    void Initialize();
+    explicit Cartridge(const std::vector<uint8_t>& romData)
+      : gRomData(romData), gCountryCode(CountryCode::Unknown), gVersion(0), gGameTitle("Unknown"), gRomCRC(0) {
+  }
+  void Initialize();
     const std::string& GetGameTitle();
     std::string GetCountryCode();
     CountryCode GetCountry();