diff --git a/r5dev/datacache/mdlcache.h b/r5dev/datacache/mdlcache.h
index 407fa68a..b1b45b2a 100644
--- a/r5dev/datacache/mdlcache.h
+++ b/r5dev/datacache/mdlcache.h
@@ -176,7 +176,7 @@ struct studioanimcache_t
 	const char* rigName;
 	int unk0;
 	int numSequences;
-	PakPage_t sequences;
+	PakPage_u sequences;
 	int unk1;
 	int unk2;
 };
diff --git a/r5dev/engine/cmodel_bsp.cpp b/r5dev/engine/cmodel_bsp.cpp
index 25949fdc..b5511af7 100644
--- a/r5dev/engine/cmodel_bsp.cpp
+++ b/r5dev/engine/cmodel_bsp.cpp
@@ -236,8 +236,8 @@ void Mod_QueuedPakCacheFrame()
         {
             if (*data->pakName)
             {
-                PakLoadedInfo_t* const pakInfo = Pak_GetPakInfo(data->pakId);
-                EPakStatus status;
+                PakLoadedInfo_s* const pakInfo = Pak_GetPakInfo(data->pakId);
+                PakStatus_e status;
 
                 // TODO: revisit this, this appears incorrect but also the way
                 // respawn does this. it this always supposed to be true on
@@ -423,7 +423,7 @@ CHECK_FOR_FAILURE:
 
     if (commonData->pakId != PAK_INVALID_HANDLE)
     {
-        const PakLoadedInfo_t* const pli = Pak_GetPakInfo(commonData->pakId);
+        const PakLoadedInfo_s* const pli = Pak_GetPakInfo(commonData->pakId);
 
         if (pli->handle != commonData->pakId || ((pli->status - 9) & 0xFFFFFFFB) != 0)
         {
diff --git a/r5dev/public/rtech/ipakfile.h b/r5dev/public/rtech/ipakfile.h
index f3aab5e5..7c29e02e 100644
--- a/r5dev/public/rtech/ipakfile.h
+++ b/r5dev/public/rtech/ipakfile.h
@@ -95,7 +95,7 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
 //-----------------------------------------------------------------------------
-struct PakFile_t;
+struct PakFile_s;
 
 //-----------------------------------------------------------------------------
 // Handle types
@@ -106,7 +106,7 @@ typedef uint64_t PakGuid_t;
 //-----------------------------------------------------------------------------
 // Page handle types
 //-----------------------------------------------------------------------------
-struct PakPageHeader_t
+struct PakPageHeader_s
 {
 	uint32_t segmentIdx;
 	uint32_t pageAlignment;
@@ -120,7 +120,7 @@ struct PakPageHeader_t
 #define IS_PAKPTR_VALID(pak, ptr) ((ptr)->index != UINT32_MAX && (ptr)->offset != UINT32_MAX && (ptr)->index < (pak)->GetPageCount() && (ptr)->offset <= (pak)->GetPageSize((ptr)->index))
 #define ASSERT_PAKPTR_VALID(pak, ptr) Assert(IS_PAKPTR_VALID(pak, ptr), "Invalid pak page pointer")
 
-union PakPage_t
+union PakPage_u
 {
 	struct
 	{
@@ -133,7 +133,7 @@ union PakPage_t
 //-----------------------------------------------------------------------------
 // Enumerations
 //-----------------------------------------------------------------------------
-enum EPakDecodeMode : int32_t
+enum PakDecodeMode_e
 {
 	MODE_DISABLED = -1,
 
@@ -142,7 +142,7 @@ enum EPakDecodeMode : int32_t
 	MODE_ZSTD
 };
 
-enum EPakStreamSet
+enum PakStreamSet_e
 {
 	STREAMING_SET_MANDATORY = 0,
 	STREAMING_SET_OPTIONAL,
@@ -151,7 +151,7 @@ enum EPakStreamSet
 	STREAMING_SET_COUNT
 };
 
-enum EPakStatus : int32_t
+enum PakStatus_e
 {
 	PAK_STATUS_FREED = 0,
 	PAK_STATUS_LOAD_PENDING = 1,
@@ -171,7 +171,7 @@ enum EPakStatus : int32_t
 	PAK_STATUS_BUSY = 15
 };
 
-struct PakAssetBinding_t
+struct PakAssetBinding_s
 {
 	enum EType
 	{
@@ -210,15 +210,15 @@ struct PakAssetBinding_t
 	// [ PIXIE ]: Should be the full size across Season 0-3.
 };
 
-struct PakAsset_t
+struct PakAsset_s
 {
 	// the guid of this asset, which will be used to index into, and retrieve
 	// this asset from the hash table
 	PakGuid_t guid;
 	uint64_t padding; // Unknown.
 
-	PakPage_t headPtr;
-	PakPage_t dataPtr;
+	PakPage_u headPtr;
+	PakPage_u dataPtr;
 
 	// offset to the streaming data in the streaming set
 	uint64_t streamingDataFileOffset[STREAMING_SET_COUNT];
@@ -244,7 +244,7 @@ struct PakAsset_t
 	}
 };
 
-struct PakAssetShort_t
+struct PakAssetShort_s
 {
 	PakGuid_t guid;
 	uint32_t trackerIndex;
@@ -273,7 +273,7 @@ struct PakTracker_s
 	char gap_9DC04[522240];
 };
 
-class PakLoadedInfo_t
+class PakLoadedInfo_s
 {
 public:
 	struct StreamingInfo_t
@@ -297,7 +297,7 @@ public:
 	};
 
 	PakHandle_t handle;
-	EPakStatus status;
+	PakStatus_e status;
 	JobID_t loadJobId;
 	uint32_t padding_maybe;
 
@@ -312,7 +312,7 @@ public:
 	void* segmentBuffers[PAK_SEGMENT_BUFFER_TYPES];
 	_QWORD qword50;
 	FILETIME fileTime;
-	PakFile_t* pakFile;
+	PakFile_s* pakFile;
 	StreamingInfo_t streamInfo[STREAMING_SET_COUNT];
 	uint32_t fileHandle;
 	uint8_t m_nUnk5;
@@ -320,11 +320,11 @@ public:
 
 }; //Size: 0x00B8/0x00E8
 
-struct PakGlobals_s
+struct PakGlobalState_s
 {
 	// [ PIXIE ]: Max possible registered assets on Season 3, 0-2 I did not check yet.
-	PakAssetBinding_t assetBindings[PAK_MAX_TRACKED_TYPES];
-	PakAssetShort_t loadedAssets[PAK_MAX_LOADED_ASSETS];
+	PakAssetBinding_s assetBindings[PAK_MAX_TRACKED_TYPES];
+	PakAssetShort_s loadedAssets[PAK_MAX_LOADED_ASSETS];
 
 	// assets that are tracked across all asset types
 	PakAssetTracker_s trackedAssets[PAK_MAX_TRACKED_ASSETS];
@@ -333,7 +333,7 @@ struct PakGlobals_s
 	RHashMap loadedPakMap;    // links to 'loadedPaks'
 
 	// all currently loaded pak handles
-	PakLoadedInfo_t loadedPaks[PAK_MAX_LOADED_PAKS];
+	PakLoadedInfo_s loadedPaks[PAK_MAX_LOADED_PAKS];
 
 	RMultiHashMap unkMap2; // links to 'unkIntArray' and 'unkIntArray2'
 	int unkIntArray[PAK_MAX_TRACKED_ASSETS];
@@ -395,19 +395,19 @@ struct PakGlobals_s
 	uint8_t* patchNumbers;
 };
 
-struct PakPatchFileHeader_t
+struct PakPatchFileHeader_s
 {
 	uint64_t compressedSize;
 	uint64_t decompressedSize;
 };
 
-struct PakPatchDataHeader_t
+struct PakPatchDataHeader_s
 {
 	uint32_t editStreamSize;
 	uint32_t pageCount;
 };
 
-struct PakFileHeader_t
+struct PakFileHeader_s
 {
 	inline uint32_t GetTotalStreamingNamesBufferSize() const
 	{
@@ -425,30 +425,30 @@ struct PakFileHeader_t
 
 	inline uint64_t GetTotalHeaderSize() const
 	{
-		uint64_t headerSize = sizeof(PakFileHeader_t);
+		uint64_t headerSize = sizeof(PakFileHeader_s);
 
 		// if we have patches, we should include the patch header as well
 		if (patchIndex > 0)
-			headerSize += sizeof(PakPatchDataHeader_t);
+			headerSize += sizeof(PakPatchDataHeader_s);
 
 		// the streaming file paths belong to the header as well
 		headerSize += GetTotalStreamingNamesBufferSize();
 		return headerSize;
 	}
 
-	inline EPakDecodeMode GetCompressionMode() const
+	inline PakDecodeMode_e GetCompressionMode() const
 	{
 		if (flags & PAK_HEADER_FLAGS_ZSTREAM_ENCODED)
-			return EPakDecodeMode::MODE_ZSTD;
+			return PakDecodeMode_e::MODE_ZSTD;
 
 		// NOTE: this should be the first check once we rebuilt function
 		// 14043F300 and alloc ring buffer for the flags individually instead
 		// instead of having to define the main compress flag (which really
 		// just means that the pak is using the RTech decoder)
 		else if (flags & PAK_HEADER_FLAGS_COMPRESSED)
-			return EPakDecodeMode::MODE_RTECH;
+			return PakDecodeMode_e::MODE_RTECH;
 
-		return EPakDecodeMode::MODE_DISABLED;
+		return PakDecodeMode_e::MODE_DISABLED;
 	}
 
 	// file versions
@@ -501,7 +501,7 @@ struct PakFileHeader_t
 	uint32_t memPageOffset;
 
 	uint8_t  unk3[0x8];
-}; static_assert(sizeof(PakFileHeader_t) == 0x80);
+}; static_assert(sizeof(PakFileHeader_s) == 0x80);
 
 // segment flags
 #define SF_HEAD (0)
@@ -509,14 +509,14 @@ struct PakFileHeader_t
 #define SF_CPU  (1 << 1) // 0x2
 #define SF_DEV  (1 << 8) // 0x80
 
-struct PakSegmentHeader_t
+struct PakSegmentHeader_s
 {
 	int typeFlags;
 	int dataAlignment;
 	size_t dataSize;
 };
 
-struct PakSegmentDescriptor_t
+struct PakSegmentDescriptor_s
 {
 	size_t assetTypeCount[PAK_MAX_TRACKED_TYPES];
 	int64_t segmentSizes[PAK_MAX_SEGMENTS];
@@ -525,7 +525,7 @@ struct PakSegmentDescriptor_t
 	int segmentAlignmentForType[PAK_SEGMENT_BUFFER_TYPES];
 };
 
-struct PakDecoder_t
+struct PakDecoder_s
 {
 	const uint8_t* inputBuf;
 	uint8_t* outputBuf;
@@ -542,7 +542,7 @@ struct PakDecoder_t
 	uint32_t headerOffset;
 
 	// this field was unused, it now contains the decoder mode
-	EPakDecodeMode decodeMode;
+	PakDecodeMode_e decodeMode;
 
 	// NOTE: unless you are in the RTech decoder, use the getter if you need to
 	// get the current pos!!!
@@ -579,13 +579,13 @@ struct PakDecoder_t
 	};
 };
 
-struct PakRingBufferFrame_t
+struct PakRingBufferFrame_s
 {
 	size_t bufIndex;
 	size_t frameLen;
 };
 
-struct PakFileStream_t
+struct PakFileStream_s
 {
 	struct Descriptor
 	{
@@ -595,7 +595,7 @@ struct PakFileStream_t
 
 		// NOTE: if this is set, the game sets 'PakMemoryData_t::processedPatchedDataSize'
 		// to 'dataOffset'; else its getting set to 'sizeof(PakFileHeader_t)'.
-		EPakDecodeMode compressionMode;
+		PakDecodeMode_e compressionMode;
 	};
 
 	_QWORD qword0;
@@ -615,11 +615,11 @@ struct PakFileStream_t
 	_QWORD bytesStreamed;
 };
 
-typedef struct PakPatchFuncs_s
+struct PakPatchFuncs_s
 {
-	typedef bool (*PatchFunc_t)(PakFile_t* const pak, size_t* const numAvailableBytes);
+	typedef bool (*PatchFunc_t)(PakFile_s* const pak, size_t* const numAvailableBytes);
 
-	enum EPatchCommands
+	enum PatchCommands_e
 	{
 		PATCH_CMD0,
 		PATCH_CMD1,
@@ -641,9 +641,9 @@ typedef struct PakPatchFuncs_s
 
 	PatchFunc_t patchFuncs[PATCH_CMD_COUNT];
 
-} PakPatchFuncs_t;
+};
 
-struct PakMemoryData_t
+struct PakMemoryData_s
 {
 	uint64_t processedPatchedDataSize;
 	char* patchData; // pointer to patch stream data
@@ -675,24 +675,24 @@ struct PakMemoryData_t
 	int* loadedAssetIndices;
 	uint8_t** memPageBuffers;
 
-	PakPatchFileHeader_t* patchHeaders;
+	PakPatchFileHeader_s* patchHeaders;
 	unsigned short* patchIndices;
 
 	char* streamingFilePaths[STREAMING_SET_COUNT];
 
-	PakSegmentHeader_t* segmentHeaders;
-	PakPageHeader_t* pageHeaders;
+	PakSegmentHeader_s* segmentHeaders;
+	PakPageHeader_s* pageHeaders;
 
-	PakPage_t* virtualPointers;
-	PakAsset_t* assetEntries;
+	PakPage_u* virtualPointers;
+	PakAsset_s* assetEntries;
 
-	PakPage_t* guidDescriptors;
+	PakPage_u* guidDescriptors;
 	uint32_t* fileRelations;
 
 	char gap5E0[32];
 
-	PakPatchDataHeader_t* patchDataHeader;
-	PakAsset_t** ppAssetEntries;
+	PakPatchDataHeader_s* patchDataHeader;
+	PakAsset_s** ppAssetEntries;
 
 	int someAssetCount;
 	int numShiftedPointers;
@@ -701,11 +701,11 @@ struct PakMemoryData_t
 	__int64 unkAssetTypeBindingSizes[PAK_MAX_TRACKED_TYPES];
 
 	const char* fileName;
-	PakFileHeader_t pakHeader;
-	PakPatchFileHeader_t patchHeader;
+	PakFileHeader_s pakHeader;
+	PakPatchFileHeader_s patchHeader;
 };
 
-struct PakFile_t
+struct PakFile_s
 {
 	int numProcessedPointers;
 	uint32_t processedAssetCount;
@@ -715,26 +715,26 @@ struct PakFile_t
 	uint32_t patchCount;
 	uint32_t dword14;
 
-	PakFileStream_t fileStream;
+	PakFileStream_s fileStream;
 	uint64_t inputBytePos;
 	uint8_t byte1F8;
 	char gap1F9[4];
 	uint8_t byte1FD;
 	bool isOffsetted_MAYBE;
 	bool isCompressed;
-	PakDecoder_t pakDecoder;
+	PakDecoder_s pakDecoder;
 	uint8_t* decompBuffer;
 	size_t maxCopySize;
 	uint64_t qword298;
 
-	PakMemoryData_t memoryData;
+	PakMemoryData_s memoryData;
 
 	inline const char* GetName() const
 	{
 		return memoryData.fileName;
 	}
 
-	inline const PakFileHeader_t& GetHeader() const
+	inline const PakFileHeader_s& GetHeader() const
 	{
 		return memoryData.pakHeader;
 	}
@@ -771,7 +771,7 @@ struct PakFile_t
 		return true;
 	}
 
-	inline const PakPageHeader_t* GetPageHeader(const uint32_t i) const
+	inline const PakPageHeader_s* GetPageHeader(const uint32_t i) const
 	{
 		assert(i != UINT32_MAX && i < GetPageCount());
 
@@ -791,14 +791,14 @@ struct PakFile_t
 		return memoryData.memPageBuffers[index] + offset;
 	}
 
-	inline void* GetPointerForPageOffset(const PakPage_t& ptr) const
+	inline void* GetPointerForPageOffset(const PakPage_u& ptr) const
 	{
 		assert(IsPageOffsetValid(ptr.index, ptr.offset));
 
 		return memoryData.memPageBuffers[ptr.index] + ptr.offset;
 	}
 
-	inline void* GetPointerForPageOffset(const PakPage_t* ptr) const
+	inline void* GetPointerForPageOffset(const PakPage_u* ptr) const
 	{
 		assert(IsPageOffsetValid(ptr->index, ptr->offset));
 
@@ -811,7 +811,7 @@ struct PakFile_t
 		return GetHeader().virtualSegmentCount;
 	}
 
-	inline const PakSegmentHeader_t* GetSegmentHeader(const uint32_t i) const
+	inline const PakSegmentHeader_s* GetSegmentHeader(const uint32_t i) const
 	{
 		assert(i < GetSegmentCount());
 
@@ -821,11 +821,11 @@ struct PakFile_t
 
 
 static_assert(sizeof(PakTracker_s) == 0x11D410);
-static_assert(sizeof(PakFile_t) == 2224); // S3+
-static_assert(sizeof(PakLoadedInfo_t) == 184);
-static_assert(sizeof(PakDecoder_t) == 136);
-static_assert(sizeof(PakPatchFileHeader_t) == 16);
-static_assert(sizeof(PakPatchDataHeader_t) == 8);
-static_assert(sizeof(PakGlobals_s) == 0xC98A48);
+static_assert(sizeof(PakFile_s) == 2224); // S3+
+static_assert(sizeof(PakLoadedInfo_s) == 184);
+static_assert(sizeof(PakDecoder_s) == 136);
+static_assert(sizeof(PakPatchFileHeader_s) == 16);
+static_assert(sizeof(PakPatchDataHeader_s) == 8);
+static_assert(sizeof(PakGlobalState_s) == 0xC98A48);
 
 #endif // RTECH_IPACKFILE_H
diff --git a/r5dev/rtech/pak/pakalloc.cpp b/r5dev/rtech/pak/pakalloc.cpp
index 31b0f5eb..0533bded 100644
--- a/r5dev/rtech/pak/pakalloc.cpp
+++ b/r5dev/rtech/pak/pakalloc.cpp
@@ -10,14 +10,14 @@
 //-----------------------------------------------------------------------------
 // aligns the segment headers for each asset type
 //-----------------------------------------------------------------------------
-void Pak_AlignSegmentHeaders(PakFile_t* const pak, PakSegmentDescriptor_t* const desc)
+void Pak_AlignSegmentHeaders(PakFile_s* const pak, PakSegmentDescriptor_s* const desc)
 {
     uint64_t headersSize = 0;
     uint8_t headerSegmentAlignment = static_cast<int8_t>(desc->segmentAlignmentForType[SF_HEAD]);
 
     for (uint8_t i = 0; i < PAK_MAX_TRACKED_TYPES; ++i)
     {
-        const PakAssetBinding_t& binding = g_pakGlobals->assetBindings[i];
+        const PakAssetBinding_s& binding = g_pakGlobals->assetBindings[i];
 
         if (desc->assetTypeCount[i])
         {
@@ -41,11 +41,11 @@ void Pak_AlignSegmentHeaders(PakFile_t* const pak, PakSegmentDescriptor_t* const
 //-----------------------------------------------------------------------------
 // aligns each individual non-header segment
 //-----------------------------------------------------------------------------
-void Pak_AlignSegments(PakFile_t* const pak, PakSegmentDescriptor_t* const desc)
+void Pak_AlignSegments(PakFile_s* const pak, PakSegmentDescriptor_s* const desc)
 {
     for (uint16_t i = 0; i < pak->GetSegmentCount(); ++i)
     {
-        const PakSegmentHeader_t* const segHeader = pak->GetSegmentHeader(i);
+        const PakSegmentHeader_s* const segHeader = pak->GetSegmentHeader(i);
 
         const uint8_t segmentType = segHeader->typeFlags & (SF_TEMP | SF_CPU);
 
@@ -71,14 +71,14 @@ void Pak_AlignSegments(PakFile_t* const pak, PakSegmentDescriptor_t* const desc)
 //-----------------------------------------------------------------------------
 // copy's pages into pre-allocated and aligned segments
 //-----------------------------------------------------------------------------
-void Pak_CopyPagesToSegments(PakFile_t* const pak, PakLoadedInfo_t* const loadedInfo, PakSegmentDescriptor_t* const desc)
+void Pak_CopyPagesToSegments(PakFile_s* const pak, PakLoadedInfo_s* const loadedInfo, PakSegmentDescriptor_s* const desc)
 {
     for (uint32_t i = 0; i < pak->GetPageCount(); ++i)
     {
-        const PakPageHeader_t* const pageHeader = pak->GetPageHeader(i);
+        const PakPageHeader_s* const pageHeader = pak->GetPageHeader(i);
         const uint32_t segmentIndex = pageHeader->segmentIdx;
 
-        const PakSegmentHeader_t* const segHeader = pak->GetSegmentHeader(segmentIndex);
+        const PakSegmentHeader_s* const segHeader = pak->GetSegmentHeader(segmentIndex);
         const int typeFlags = segHeader->typeFlags;
 
         // check if header page
diff --git a/r5dev/rtech/pak/pakalloc.h b/r5dev/rtech/pak/pakalloc.h
index 9d2b2a81..58d06382 100644
--- a/r5dev/rtech/pak/pakalloc.h
+++ b/r5dev/rtech/pak/pakalloc.h
@@ -2,12 +2,12 @@
 #define RTECH_PAKALLOC_H
 #include "rtech/ipakfile.h"
 
-extern void Pak_AlignSegmentHeaders(PakFile_t* const pak, PakSegmentDescriptor_t* const desc);
-extern void Pak_AlignSegments(PakFile_t* const pak, PakSegmentDescriptor_t* const desc);
-extern void Pak_CopyPagesToSegments(PakFile_t* const pak, PakLoadedInfo_t* const loadedInfo, PakSegmentDescriptor_t* const desc);
+extern void Pak_AlignSegmentHeaders(PakFile_s* const pak, PakSegmentDescriptor_s* const desc);
+extern void Pak_AlignSegments(PakFile_s* const pak, PakSegmentDescriptor_s* const desc);
+extern void Pak_CopyPagesToSegments(PakFile_s* const pak, PakLoadedInfo_s* const loadedInfo, PakSegmentDescriptor_s* const desc);
 
 // something with sorting pages?
-inline void (*sub_140442740)(PakAsset_t** assetEntries, PakAsset_t** assetEntry, __int64 idx, PakFile_t* pak);
+inline void (*sub_140442740)(PakAsset_s** assetEntries, PakAsset_s** assetEntry, __int64 idx, PakFile_s* pak);
 
 ///////////////////////////////////////////////////////////////////////////////
 class V_PakAlloc : public IDetour
diff --git a/r5dev/rtech/pak/pakdecode.cpp b/r5dev/rtech/pak/pakdecode.cpp
index cbbf229c..936e6893 100644
--- a/r5dev/rtech/pak/pakdecode.cpp
+++ b/r5dev/rtech/pak/pakdecode.cpp
@@ -135,7 +135,7 @@ static const unsigned char /*141313180*/ s_defaultDecoderLUT[] =
 //-----------------------------------------------------------------------------
 // checks if we have enough output buffer room to decode the data stream
 //-----------------------------------------------------------------------------
-bool Pak_HasEnoughDecodeBufferAvailable(PakDecoder_t* const decoder, const size_t outLen)
+bool Pak_HasEnoughDecodeBufferAvailable(PakDecoder_s* const decoder, const size_t outLen)
 {
 	// make sure caller has copied all data out the ring buffer first before
 	// overwriting it with new decoded data
@@ -146,7 +146,7 @@ bool Pak_HasEnoughDecodeBufferAvailable(PakDecoder_t* const decoder, const size_
 //-----------------------------------------------------------------------------
 // checks if we have enough source data streamed to decode the next block
 //-----------------------------------------------------------------------------
-bool Pak_HasEnoughStreamedDataForDecode(PakDecoder_t* const decoder, const size_t inLen)
+bool Pak_HasEnoughStreamedDataForDecode(PakDecoder_s* const decoder, const size_t inLen)
 {
 	// the decoder needs at least this amount of input data streamed in order
 	// to decode the rest of the pak file, as this is where reading has stopped
@@ -160,9 +160,9 @@ bool Pak_HasEnoughStreamedDataForDecode(PakDecoder_t* const decoder, const size_
 // gets the frame for the data in the ring buffer, the frame returned is always
 // ending to the end of the ring buffer, or the end of the data itself
 //-----------------------------------------------------------------------------
-PakRingBufferFrame_t Pak_DetermineRingBufferFrame(const uint64_t bufMask, const size_t seekPos, const size_t dataLen)
+PakRingBufferFrame_s Pak_DetermineRingBufferFrame(const uint64_t bufMask, const size_t seekPos, const size_t dataLen)
 {
-	PakRingBufferFrame_t ring;
+	PakRingBufferFrame_s ring;
 	ring.bufIndex = seekPos & bufMask;
 
 	// the total amount of bytes used and available in this frame
@@ -178,7 +178,7 @@ PakRingBufferFrame_t Pak_DetermineRingBufferFrame(const uint64_t bufMask, const
 //-----------------------------------------------------------------------------
 // initializes the RTech decoder
 //-----------------------------------------------------------------------------
-size_t Pak_RTechDecoderInit(PakDecoder_t* const decoder, const uint8_t* const fileBuffer,
+size_t Pak_RTechDecoderInit(PakDecoder_s* const decoder, const uint8_t* const fileBuffer,
 	const uint64_t inputMask, const size_t dataSize, const size_t dataOffset, const size_t headerSize)
 {
 	uint64_t frameHeader = *(_QWORD*)((inputMask & (dataOffset + headerSize)) + fileBuffer);
@@ -243,7 +243,7 @@ size_t Pak_RTechDecoderInit(PakDecoder_t* const decoder, const uint8_t* const fi
 //-----------------------------------------------------------------------------
 // decodes the RTech data stream up to available buffer or data
 //-----------------------------------------------------------------------------
-bool Pak_RTechStreamDecode(PakDecoder_t* const decoder, const size_t inLen, const size_t outLen)
+bool Pak_RTechStreamDecode(PakDecoder_s* const decoder, const size_t inLen, const size_t outLen)
 {
 	bool result; // al
 	uint64_t outBufBytePos; // r15
@@ -570,7 +570,7 @@ LABEL_69:
 //-----------------------------------------------------------------------------
 // initializes the ZStd decoder
 //-----------------------------------------------------------------------------
-size_t Pak_ZStdDecoderInit(PakDecoder_t* const decoder, const uint8_t* frameHeader,
+size_t Pak_ZStdDecoderInit(PakDecoder_s* const decoder, const uint8_t* frameHeader,
 	const size_t dataSize, const size_t headerSize)
 {
 	ZSTD_DStream* const dctx = ZSTD_createDStream();
@@ -608,7 +608,7 @@ size_t Pak_ZStdDecoderInit(PakDecoder_t* const decoder, const uint8_t* frameHead
 // decodes the ZStd data stream up to available buffer or data, whichever ends
 // first
 //-----------------------------------------------------------------------------
-bool Pak_ZStdStreamDecode(PakDecoder_t* const decoder, const PakRingBufferFrame_t& outFrame, const PakRingBufferFrame_t& inFrame)
+bool Pak_ZStdStreamDecode(PakDecoder_s* const decoder, const PakRingBufferFrame_s& outFrame, const PakRingBufferFrame_s& inFrame)
 {
 	ZSTD_outBuffer outBuffer = {
 		&decoder->outputBuf[outFrame.bufIndex],
@@ -663,9 +663,9 @@ bool Pak_ZStdStreamDecode(PakDecoder_t* const decoder, const PakRingBufferFrame_
 //-----------------------------------------------------------------------------
 // initializes the decoder
 //-----------------------------------------------------------------------------
-size_t Pak_InitDecoder(PakDecoder_t* const decoder, const uint8_t* const inputBuf, uint8_t* const outputBuf,
+size_t Pak_InitDecoder(PakDecoder_s* const decoder, const uint8_t* const inputBuf, uint8_t* const outputBuf,
 	const uint64_t inputMask, const uint64_t outputMask, const size_t dataSize, const size_t dataOffset,
-	const size_t headerSize, const EPakDecodeMode decodeMode)
+	const size_t headerSize, const PakDecodeMode_e decodeMode)
 {
 	// buffer size must be power of two as we index into buffers using a bit
 	// mask rather than a modulo, the mask provided must be bufferSize-1
@@ -696,7 +696,7 @@ size_t Pak_InitDecoder(PakDecoder_t* const decoder, const uint8_t* const inputBu
 
 	// if we use the default RTech decoder, return from here as the stuff below
 	// is handled by the RTech decoder internally
-	if (decodeMode == EPakDecodeMode::MODE_RTECH)
+	if (decodeMode == PakDecodeMode_e::MODE_RTECH)
 		return Pak_RTechDecoderInit(decoder, inputBuf, inputMask, dataSize, dataOffset, headerSize);
 
 	// NOTE: on RTech encoded paks this data is parsed out of the frame header,
@@ -721,7 +721,7 @@ size_t Pak_InitDecoder(PakDecoder_t* const decoder, const uint8_t* const inputBu
 // from where the base pak had ended as patch pak files are considered part of
 // the pak file that's currently getting loaded
 //-----------------------------------------------------------------------------
-bool Pak_StreamToBufferDecode(PakDecoder_t* const decoder, const size_t inLen, const size_t outLen, const EPakDecodeMode decodeMode)
+bool Pak_StreamToBufferDecode(PakDecoder_s* const decoder, const size_t inLen, const size_t outLen, const PakDecodeMode_e decodeMode)
 {
 	if (!Pak_HasEnoughStreamedDataForDecode(decoder, inLen))
 		return false;
@@ -729,7 +729,7 @@ bool Pak_StreamToBufferDecode(PakDecoder_t* const decoder, const size_t inLen, c
 	if (!Pak_HasEnoughDecodeBufferAvailable(decoder, outLen))
 		return false;
 
-	if (decodeMode == EPakDecodeMode::MODE_RTECH)
+	if (decodeMode == PakDecodeMode_e::MODE_RTECH)
 		return Pak_RTechStreamDecode(decoder, inLen, outLen);
 
 	// must have a decoder at this point
@@ -739,8 +739,8 @@ bool Pak_StreamToBufferDecode(PakDecoder_t* const decoder, const size_t inLen, c
 	// this position in code
 	assert(decoder->zstreamContext && decoder->inBufBytePos <= inLen);
 
-	const PakRingBufferFrame_t outFrame = Pak_DetermineRingBufferFrame(decoder->outputMask, decoder->outBufBytePos , outLen);
-	const PakRingBufferFrame_t inFrame  = Pak_DetermineRingBufferFrame(decoder->inputMask, decoder->inBufBytePos, inLen);
+	const PakRingBufferFrame_s outFrame = Pak_DetermineRingBufferFrame(decoder->outputMask, decoder->outBufBytePos , outLen);
+	const PakRingBufferFrame_s inFrame  = Pak_DetermineRingBufferFrame(decoder->inputMask, decoder->inBufBytePos, inLen);
 
 	return Pak_ZStdStreamDecode(decoder, outFrame, inFrame);
 }
@@ -748,14 +748,14 @@ bool Pak_StreamToBufferDecode(PakDecoder_t* const decoder, const size_t inLen, c
 //-----------------------------------------------------------------------------
 // decodes buffered input pak data
 //-----------------------------------------------------------------------------
-bool Pak_BufferToBufferDecode(uint8_t* const inBuf, uint8_t* const outBuf, const size_t pakSize, const EPakDecodeMode decodeMode)
+bool Pak_BufferToBufferDecode(uint8_t* const inBuf, uint8_t* const outBuf, const size_t pakSize, const PakDecodeMode_e decodeMode)
 {
-	assert(decodeMode != EPakDecodeMode::MODE_DISABLED);
+	assert(decodeMode != PakDecodeMode_e::MODE_DISABLED);
 
-	PakDecoder_t decoder{};
-	const size_t decompressedSize = Pak_InitDecoder(&decoder, inBuf, outBuf, UINT64_MAX, UINT64_MAX, pakSize, NULL, sizeof(PakFileHeader_t), decodeMode);
+	PakDecoder_s decoder{};
+	const size_t decompressedSize = Pak_InitDecoder(&decoder, inBuf, outBuf, UINT64_MAX, UINT64_MAX, pakSize, NULL, sizeof(PakFileHeader_s), decodeMode);
 
-	PakFileHeader_t* const inHeader = reinterpret_cast<PakFileHeader_t*>(inBuf);
+	PakFileHeader_s* const inHeader = reinterpret_cast<PakFileHeader_s*>(inBuf);
 
 	if (decompressedSize != inHeader->decompressedSize)
 	{
@@ -774,7 +774,7 @@ bool Pak_BufferToBufferDecode(uint8_t* const inBuf, uint8_t* const outBuf, const
 		return false;
 	}
 
-	PakFileHeader_t* const outHeader = reinterpret_cast<PakFileHeader_t*>(outBuf);
+	PakFileHeader_s* const outHeader = reinterpret_cast<PakFileHeader_s*>(outBuf);
 
 	// copy the header over to the decoded buffer
 	*outHeader = *inHeader;
@@ -826,7 +826,7 @@ bool Pak_DecodePakFile(const char* const inPakFile, const char* const outPakFile
 
 	const size_t fileSize = inPakStream.GetSize();
 
-	if (fileSize <= sizeof(PakFileHeader_t))
+	if (fileSize <= sizeof(PakFileHeader_s))
 	{
 		Error(eDLL_T::RTECH, NO_ERROR, "%s: pak '%s' appears truncated!\n",
 			__FUNCTION__, inPakFile);
@@ -840,7 +840,7 @@ bool Pak_DecodePakFile(const char* const inPakFile, const char* const outPakFile
 	inPakStream.Read(inPakBuf, fileSize);
 	inPakStream.Close();
 
-	PakFileHeader_t* const inHeader = reinterpret_cast<PakFileHeader_t*>(inPakBuf);
+	PakFileHeader_s* const inHeader = reinterpret_cast<PakFileHeader_s*>(inPakBuf);
 
 	if (inHeader->magic != PAK_HEADER_MAGIC || inHeader->version != PAK_HEADER_VERSION)
 	{
@@ -850,9 +850,9 @@ bool Pak_DecodePakFile(const char* const inPakFile, const char* const outPakFile
 		return false;
 	}
 
-	const EPakDecodeMode decodeMode = inHeader->GetCompressionMode();
+	const PakDecodeMode_e decodeMode = inHeader->GetCompressionMode();
 
-	if (decodeMode == EPakDecodeMode::MODE_DISABLED)
+	if (decodeMode == PakDecodeMode_e::MODE_DISABLED)
 	{
 		Error(eDLL_T::RTECH, NO_ERROR, "%s: pak '%s' is already decompressed!\n",
 			__FUNCTION__, inPakFile);
@@ -881,7 +881,7 @@ bool Pak_DecodePakFile(const char* const inPakFile, const char* const outPakFile
 		return false;
 	}
 
-	const PakFileHeader_t* const outHeader = reinterpret_cast<PakFileHeader_t*>(outPakBuf);
+	const PakFileHeader_s* const outHeader = reinterpret_cast<PakFileHeader_s*>(outPakBuf);
 
 	// NOTE: if the paks this particular pak patches have different sizes than
 	// current sizes in the patch header, the runtime will crash!
diff --git a/r5dev/rtech/pak/pakdecode.h b/r5dev/rtech/pak/pakdecode.h
index 2008b012..40e6782b 100644
--- a/r5dev/rtech/pak/pakdecode.h
+++ b/r5dev/rtech/pak/pakdecode.h
@@ -2,12 +2,12 @@
 #define RTECH_PAKDECODE_H
 #include "rtech/ipakfile.h"
 
-extern size_t Pak_InitDecoder(PakDecoder_t* const decoder, const uint8_t* const inputBuf, uint8_t* const outputBuf,
+extern size_t Pak_InitDecoder(PakDecoder_s* const decoder, const uint8_t* const inputBuf, uint8_t* const outputBuf,
 	const uint64_t inputMask, const uint64_t outputMask, const size_t dataSize, const size_t dataOffset,
-	const size_t headerSize, const EPakDecodeMode decodeMode);
+	const size_t headerSize, const PakDecodeMode_e decodeMode);
 
-extern bool Pak_StreamToBufferDecode(PakDecoder_t* const decoder, const size_t inLen, const size_t outLen, const EPakDecodeMode decodeMode);
-extern bool Pak_BufferToBufferDecode(uint8_t* const inBuf, uint8_t* const outBuf, const size_t pakSize, const EPakDecodeMode decodeMode);
+extern bool Pak_StreamToBufferDecode(PakDecoder_s* const decoder, const size_t inLen, const size_t outLen, const PakDecodeMode_e decodeMode);
+extern bool Pak_BufferToBufferDecode(uint8_t* const inBuf, uint8_t* const outBuf, const size_t pakSize, const PakDecodeMode_e decodeMode);
 
 extern bool Pak_DecodePakFile(const char* const inPakFile, const char* const outPakFile);
 
diff --git a/r5dev/rtech/pak/pakencode.cpp b/r5dev/rtech/pak/pakencode.cpp
index 99df0017..8f9fb70c 100644
--- a/r5dev/rtech/pak/pakencode.cpp
+++ b/r5dev/rtech/pak/pakencode.cpp
@@ -35,7 +35,7 @@ bool Pak_BufferToBufferEncode(const uint8_t* const inBuf, const uint64_t inLen,
 {
 	// offset to the actual pak data, the main file header shouldn't be
 	// compressed
-	const size_t dataOffset = sizeof(PakFileHeader_t);
+	const size_t dataOffset = sizeof(PakFileHeader_s);
 
 	uint8_t* const dstBuf = outBuf + dataOffset;
 	const size_t dstLen = outLen - dataOffset;
@@ -55,7 +55,7 @@ bool Pak_BufferToBufferEncode(const uint8_t* const inBuf, const uint64_t inLen,
 		return false;
 	}
 
-	PakFileHeader_t* const outHeader = reinterpret_cast<PakFileHeader_t* const>(outBuf);
+	PakFileHeader_s* const outHeader = reinterpret_cast<PakFileHeader_s* const>(outBuf);
 
 	// the compressed size includes the entire buffer, even the data we didn't
 	// compress like the file header
@@ -105,7 +105,7 @@ bool Pak_EncodePakFile(const char* const inPakFile, const char* const outPakFile
 	const size_t fileSize = inPakStream.GetSize();
 
 	// file appears truncated
-	if (fileSize <= sizeof(PakFileHeader_t))
+	if (fileSize <= sizeof(PakFileHeader_s))
 	{
 		Error(eDLL_T::RTECH, NO_ERROR, "%s: pak '%s' appears truncated!\n",
 			__FUNCTION__, inPakFile);
@@ -119,7 +119,7 @@ bool Pak_EncodePakFile(const char* const inPakFile, const char* const outPakFile
 	inPakStream.Read(inPakBuf, fileSize);
 	inPakStream.Close();
 
-	const PakFileHeader_t* const inHeader = reinterpret_cast<PakFileHeader_t* const>(inPakBuf);
+	const PakFileHeader_s* const inHeader = reinterpret_cast<PakFileHeader_s* const>(inPakBuf);
 
 	if (inHeader->magic != PAK_HEADER_MAGIC || inHeader->version != PAK_HEADER_VERSION)
 	{
@@ -129,7 +129,7 @@ bool Pak_EncodePakFile(const char* const inPakFile, const char* const outPakFile
 		return false;
 	}
 
-	if (inHeader->GetCompressionMode() != EPakDecodeMode::MODE_DISABLED)
+	if (inHeader->GetCompressionMode() != PakDecodeMode_e::MODE_DISABLED)
 	{
 		Error(eDLL_T::RTECH, NO_ERROR, "%s: pak '%s' is already compressed!\n",
 			__FUNCTION__, inPakFile);
@@ -158,7 +158,7 @@ bool Pak_EncodePakFile(const char* const inPakFile, const char* const outPakFile
 	std::unique_ptr<uint8_t[]> outPakBufContainer(new uint8_t[outBufSize]);
 	uint8_t* const outPakBuf = outPakBufContainer.get();
 
-	PakFileHeader_t* const outHeader = reinterpret_cast<PakFileHeader_t* const>(outPakBuf);
+	PakFileHeader_s* const outHeader = reinterpret_cast<PakFileHeader_s* const>(outPakBuf);
 
 	// copy the header over
 	*outHeader = *inHeader;
@@ -172,7 +172,7 @@ bool Pak_EncodePakFile(const char* const inPakFile, const char* const outPakFile
 		return false;
 	}
 
-	const PakFileHeader_t* const outPakHeader = reinterpret_cast<PakFileHeader_t* const>(outPakBuf);
+	const PakFileHeader_s* const outPakHeader = reinterpret_cast<PakFileHeader_s* const>(outPakBuf);
 
 	Pak_ShowHeaderDetails(outPakHeader);
 
diff --git a/r5dev/rtech/pak/pakparse.cpp b/r5dev/rtech/pak/pakparse.cpp
index 6caef4e3..b95bebeb 100644
--- a/r5dev/rtech/pak/pakparse.cpp
+++ b/r5dev/rtech/pak/pakparse.cpp
@@ -19,7 +19,7 @@ static ConVar pak_debugrelations("pak_debugrelations", "0", FCVAR_DEVELOPMENTONL
 //-----------------------------------------------------------------------------
 // resolve the target guid from lookuo table
 //-----------------------------------------------------------------------------
-static bool Pak_ResolveAssetDependency(const PakFile_t* const pak, PakGuid_t currentGuid,
+static bool Pak_ResolveAssetDependency(const PakFile_s* const pak, PakGuid_t currentGuid,
     const PakGuid_t targetGuid, int& currentIndex, const bool shouldCheckTwo)
 {
     while (true)
@@ -48,9 +48,9 @@ static bool Pak_ResolveAssetDependency(const PakFile_t* const pak, PakGuid_t cur
 //-----------------------------------------------------------------------------
 // resolve guid relations for asset
 //-----------------------------------------------------------------------------
-void Pak_ResolveAssetRelations(PakFile_t* const pak, const PakAsset_t* const asset)
+void Pak_ResolveAssetRelations(PakFile_s* const pak, const PakAsset_s* const asset)
 {
-    PakPage_t* const pGuidDescriptors = &pak->memoryData.guidDescriptors[asset->dependenciesIndex];
+    PakPage_u* const pGuidDescriptors = &pak->memoryData.guidDescriptors[asset->dependenciesIndex];
     uint32_t* const v5 = (uint32_t*)g_pakGlobals->loadedPaks[pak->memoryData.pakId & PAK_MAX_LOADED_PAKS_MASK].qword50;
 
     if (pak_debugrelations.GetBool())
@@ -77,7 +77,7 @@ void Pak_ResolveAssetRelations(PakFile_t* const pak, const PakAsset_t* const ass
             // are we some special asset with the guid 2?
             if (!Pak_ResolveAssetDependency(pak, currentGuid, targetGuid, currentIndex, true))
             {
-                PakAsset_t* assetEntries = pak->memoryData.assetEntries;
+                PakAsset_s* assetEntries = pak->memoryData.assetEntries;
                 uint64_t a = 0;
 
                 for (; assetEntries->guid != targetGuid; a++, assetEntries++)
@@ -111,13 +111,13 @@ void Pak_ResolveAssetRelations(PakFile_t* const pak, const PakAsset_t* const ass
     }
 }
 
-uint32_t Pak_ProcessRemainingPagePointers(PakFile_t* const pak)
+uint32_t Pak_ProcessRemainingPagePointers(PakFile_s* const pak)
 {
     uint32_t processedPointers = 0;
 
     for (processedPointers = pak->numProcessedPointers; processedPointers < pak->GetPointerCount(); ++processedPointers)
     {
-        PakPage_t* const curPage = &pak->memoryData.virtualPointers[processedPointers];
+        PakPage_u* const curPage = &pak->memoryData.virtualPointers[processedPointers];
         int curCount = curPage->index - pak->firstPageIdx;
 
         if (curCount < 0)
@@ -126,14 +126,14 @@ uint32_t Pak_ProcessRemainingPagePointers(PakFile_t* const pak)
         if (curCount >= pak->processedPageCount)
             break;
 
-        PakPage_t* const ptr = reinterpret_cast<PakPage_t*>(pak->GetPointerForPageOffset(curPage));
+        PakPage_u* const ptr = reinterpret_cast<PakPage_u*>(pak->GetPointerForPageOffset(curPage));
         ptr->ptr = pak->memoryData.memPageBuffers[ptr->index] + ptr->offset;
     }
 
     return processedPointers;
 }
 
-void Pak_RunAssetLoadingJobs(PakFile_t* const pak)
+void Pak_RunAssetLoadingJobs(PakFile_s* const pak)
 {
     pak->numProcessedPointers = Pak_ProcessRemainingPagePointers(pak);
 
@@ -142,7 +142,7 @@ void Pak_RunAssetLoadingJobs(PakFile_t* const pak)
     if (numAssets == pak->memoryData.pakHeader.assetCount)
         return;
 
-    PakAsset_t* pakAsset = &pak->memoryData.assetEntries[numAssets];
+    PakAsset_s* pakAsset = &pak->memoryData.assetEntries[numAssets];
 
     if (pakAsset->pageEnd > pak->processedPageCount)
         return;
@@ -215,7 +215,7 @@ PakHandle_t Pak_LoadAsync(const char* const fileName, CAlignedMemAlloc* const al
 //-----------------------------------------------------------------------------
 void Pak_UnloadAsync(PakHandle_t handle)
 {
-    const PakLoadedInfo_t* const pakInfo = Pak_GetPakInfo(handle);
+    const PakLoadedInfo_s* const pakInfo = Pak_GetPakInfo(handle);
 
     if (pakInfo->fileName)
         Msg(eDLL_T::RTECH, "Unloading pak file: '%s'\n", pakInfo->fileName);
@@ -232,13 +232,13 @@ static const int s_patchCmdToBytesToProcess[] = { CMD_INVALID, CMD_INVALID, CMD_
 // loads and processes a pak file (handles decompression and patching)
 // TODO: !!! FINISH REBUILD !!!
 //----------------------------------------------------------------------------------
-bool Pak_ProcessPakFile(PakFile_t* const pak)
+bool Pak_ProcessPakFile(PakFile_s* const pak)
 {
-    PakFileStream_t* const fileStream = &pak->fileStream;
-    PakMemoryData_t* const memoryData = &pak->memoryData;
+    PakFileStream_s* const fileStream = &pak->fileStream;
+    PakMemoryData_s* const memoryData = &pak->memoryData;
 
     // first request is always just the header?
-    size_t readStart = sizeof(PakFileHeader_t);
+    size_t readStart = sizeof(PakFileHeader_s);
 
     if (fileStream->numDataChunks > 0)
         readStart = fileStream->numDataChunks * PAK_READ_DATA_CHUNK_SIZE;
@@ -261,19 +261,19 @@ bool Pak_ProcessPakFile(PakFile_t* const pak)
             fileStream->bytesStreamed += bytesProcessed;
             if (v8)
             {
-                const PakFileHeader_t* pakHeader = &pak->memoryData.pakHeader;
+                const PakFileHeader_s* pakHeader = &pak->memoryData.pakHeader;
                 const uint64_t v16 = fileStream->numDataChunksProcessed * PAK_READ_DATA_CHUNK_SIZE;
 
                 if (v8 == 2)
                 {
                     fileStream->bytesStreamed = bytesProcessed + v16;
-                    pakHeader = (PakFileHeader_t*)&fileStream->buffer[v16 & fileStream->bufferMask];
+                    pakHeader = (PakFileHeader_s*)&fileStream->buffer[v16 & fileStream->bufferMask];
                 }
 
                 const uint8_t fileIndex = fileStream->numLoadedFiles++ & PAK_MAX_ASYNC_STREAMED_LOAD_REQUESTS_MASK;
 
                 //printf("v16: %lld\n", v16);
-                fileStream->descriptors[fileIndex].dataOffset = v16 + sizeof(PakFileHeader_t);
+                fileStream->descriptors[fileIndex].dataOffset = v16 + sizeof(PakFileHeader_s);
                 fileStream->descriptors[fileIndex].compressedSize = v16 + pakHeader->compressedSize;
                 fileStream->descriptors[fileIndex].decompressedSize = pakHeader->decompressedSize;
                 fileStream->descriptors[fileIndex].compressionMode = pakHeader->GetCompressionMode();
@@ -285,18 +285,18 @@ bool Pak_ProcessPakFile(PakFile_t* const pak)
 
     for (; pak->byte1F8 != fileStream->numLoadedFiles; pak->byte1F8++)
     {
-        PakFileStream_t::Descriptor* v22 = &fileStream->descriptors[pak->byte1F8 & PAK_MAX_ASYNC_STREAMED_LOAD_REQUESTS_MASK];
+        PakFileStream_s::Descriptor* v22 = &fileStream->descriptors[pak->byte1F8 & PAK_MAX_ASYNC_STREAMED_LOAD_REQUESTS_MASK];
 
         if (pak->byte1FD)
         {
             pak->byte1FD = false;
             pak->inputBytePos = v22->dataOffset;
 
-            if (v22->compressionMode != EPakDecodeMode::MODE_DISABLED)
+            if (v22->compressionMode != PakDecodeMode_e::MODE_DISABLED)
             {
                 pak->isOffsetted_MAYBE = false;
                 pak->isCompressed = true;
-                memoryData->processedPatchedDataSize = sizeof(PakFileHeader_t);
+                memoryData->processedPatchedDataSize = sizeof(PakFileHeader_s);
             }
             else
             {
@@ -311,8 +311,8 @@ bool Pak_ProcessPakFile(PakFile_t* const pak)
                 const size_t decompressedSize = Pak_InitDecoder(&pak->pakDecoder,
                     fileStream->buffer, pak->decompBuffer,
                     PAK_DECODE_IN_RING_BUFFER_MASK, PAK_DECODE_OUT_RING_BUFFER_MASK,
-                    v22->compressedSize - (v22->dataOffset - sizeof(PakFileHeader_t)),
-                    v22->dataOffset - sizeof(PakFileHeader_t), sizeof(PakFileHeader_t), v22->compressionMode);
+                    v22->compressedSize - (v22->dataOffset - sizeof(PakFileHeader_s)),
+                    v22->dataOffset - sizeof(PakFileHeader_s), sizeof(PakFileHeader_s), v22->compressionMode);
 
                 if (decompressedSize != v22->decompressedSize)
                     Error(eDLL_T::RTECH, EXIT_FAILURE,
@@ -520,7 +520,7 @@ bool Pak_ProcessPakFile(PakFile_t* const pak)
 
 // sets patch variables for copying the next unprocessed page into the relevant segment buffer
 // if this is a header page, fetch info from the next unprocessed asset and copy over the asset's header
-bool SetupNextPageForPatching(PakLoadedInfo_t* a1, PakFile_t* pak)
+bool SetupNextPageForPatching(PakLoadedInfo_s* a1, PakFile_s* pak)
 {
     Pak_RunAssetLoadingJobs(pak);
 
@@ -538,7 +538,7 @@ bool SetupNextPageForPatching(PakLoadedInfo_t* a1, PakFile_t* pak)
     if (highestProcessedPageIdx < pak->GetPageCount())
         v26 = highestProcessedPageIdx;
 
-    const PakPageHeader_t* const nextMemPageHeader = &pak->memoryData.pageHeaders[v26];
+    const PakPageHeader_s* const nextMemPageHeader = &pak->memoryData.pageHeaders[v26];
     if ((pak->memoryData.segmentHeaders[nextMemPageHeader->segmentIdx].typeFlags & (SF_TEMP | SF_CPU)) != 0)
     {
         pak->memoryData.patchSrcSize = nextMemPageHeader->dataSize;
@@ -549,7 +549,7 @@ bool SetupNextPageForPatching(PakLoadedInfo_t* a1, PakFile_t* pak)
     }
 
     // headers
-    PakAsset_t* pakAsset = pak->memoryData.ppAssetEntries[pak->memoryData.someAssetCount];
+    PakAsset_s* pakAsset = pak->memoryData.ppAssetEntries[pak->memoryData.someAssetCount];
 
     pak->memoryData.patchSrcSize = pakAsset->headerSize;
     int assetTypeIdx = pakAsset->HashTableIndexForAssetType();
@@ -560,9 +560,9 @@ bool SetupNextPageForPatching(PakLoadedInfo_t* a1, PakFile_t* pak)
     return true;
 }
 
-bool Pak_ProcessAssets(PakLoadedInfo_t* const a1)
+bool Pak_ProcessAssets(PakLoadedInfo_s* const a1)
 {
-    PakFile_t* const pak = a1->pakFile;
+    PakFile_s* const pak = a1->pakFile;
     while (pak->processedAssetCount != pak->GetAssetCount())
     {
         // TODO: invert condition and make the branch encompass the whole loop
@@ -603,7 +603,7 @@ bool Pak_ProcessAssets(PakLoadedInfo_t* const a1)
                 break;
         }
 
-        PakAsset_t* asset = pak->memoryData.ppAssetEntries[pak->memoryData.someAssetCount];
+        PakAsset_s* asset = pak->memoryData.ppAssetEntries[pak->memoryData.someAssetCount];
         const uint32_t headPageOffset = asset->headPtr.offset;
         char* v8 = pak->memoryData.patchDstPtr - asset->headerSize;
 
@@ -616,7 +616,7 @@ bool Pak_ProcessAssets(PakLoadedInfo_t* const a1)
 
         for (uint32_t i = pak->memoryData.numShiftedPointers; i < pak->GetPointerCount(); pak->memoryData.numShiftedPointers = i)
         {
-            PakPage_t* ptr = &pak->memoryData.virtualPointers[i];
+            PakPage_u* ptr = &pak->memoryData.virtualPointers[i];
 
             ASSERT_PAKPTR_VALID(pak, ptr);
 
@@ -627,7 +627,7 @@ bool Pak_ProcessAssets(PakLoadedInfo_t* const a1)
             if (offsetToPointer >= asset->headerSize)
                 break;
 
-            PakPage_t* pagePtr = reinterpret_cast<PakPage_t*>(v8 + offsetToPointer);
+            PakPage_u* pagePtr = reinterpret_cast<PakPage_u*>(v8 + offsetToPointer);
 
             ASSERT_PAKPTR_VALID(pak, ptr);
 
@@ -641,7 +641,7 @@ bool Pak_ProcessAssets(PakLoadedInfo_t* const a1)
 
         for (uint32_t j = 0; j < asset->dependenciesCount; ++j)
         {
-            PakPage_t* descriptor = &pak->memoryData.guidDescriptors[asset->dependenciesIndex + j];
+            PakPage_u* descriptor = &pak->memoryData.guidDescriptors[asset->dependenciesIndex + j];
 
             if (descriptor->index == shiftedPageIndex)
                 descriptor->offset += offsetSize;
@@ -649,7 +649,7 @@ bool Pak_ProcessAssets(PakLoadedInfo_t* const a1)
 
         const uint32_t v16 = ++pak->memoryData.someAssetCount;
 
-        PakAsset_t* v17 = nullptr;
+        PakAsset_s* v17 = nullptr;
         if (v16 < pak->GetAssetCount() && (v17 = pak->memoryData.ppAssetEntries[v16], v17->headPtr.index == shiftedPageIndex))
         {
             pak->memoryData.field_2A8 = v17->headPtr.offset - headPageOffset - asset->headerSize;
@@ -675,7 +675,7 @@ bool Pak_ProcessAssets(PakLoadedInfo_t* const a1)
         return false;
 
     uint32_t i = 0;
-    PakAsset_t* pAsset = nullptr;
+    PakAsset_s* pAsset = nullptr;
 
     for (int j = pak->memoryData.pakId & PAK_MAX_LOADED_PAKS_MASK; i < pak->GetHeader().assetCount; a1->assetGuids[i - 1] = pAsset->guid)
     {
@@ -686,7 +686,7 @@ bool Pak_ProcessAssets(PakLoadedInfo_t* const a1)
             Pak_ResolveAssetRelations(pak, pAsset);
 
             const int assetIndex = pak->memoryData.loadedAssetIndices[i];
-            const PakAssetShort_t& loadedAsset = g_pakGlobals->loadedAssets[assetIndex];
+            const PakAssetShort_s& loadedAsset = g_pakGlobals->loadedAssets[assetIndex];
 
             if (g_pakGlobals->trackedAssets[loadedAsset.trackerIndex].loadedPakIndex == j)
             {
@@ -733,24 +733,24 @@ bool Pak_ProcessAssets(PakLoadedInfo_t* const a1)
     if (g_pakGlobals->pakTracker)
         sub_14043D870(a1, 0);
 
-    a1->status = EPakStatus::PAK_STATUS_LOADED;
+    a1->status = PakStatus_e::PAK_STATUS_LOADED;
 
     return true;
 }
 
-void Pak_StubInvalidAssetBinds(PakFile_t* const pak, PakSegmentDescriptor_t* const desc)
+void Pak_StubInvalidAssetBinds(PakFile_s* const pak, PakSegmentDescriptor_s* const desc)
 {
     for (uint32_t i = 0; i < pak->GetAssetCount(); ++i)
     {
-        PakAsset_t* const asset = &pak->memoryData.assetEntries[i];
+        PakAsset_s* const asset = &pak->memoryData.assetEntries[i];
         pak->memoryData.ppAssetEntries[i] = asset;
 
         const uint8_t assetTypeIndex = asset->HashTableIndexForAssetType();
         desc->assetTypeCount[assetTypeIndex]++;
 
-        PakAssetBinding_t* const assetBinding = &g_pakGlobals->assetBindings[assetTypeIndex];
+        PakAssetBinding_s* const assetBinding = &g_pakGlobals->assetBindings[assetTypeIndex];
 
-        if (assetBinding->type == PakAssetBinding_t::NONE)
+        if (assetBinding->type == PakAssetBinding_s::NONE)
         {
             assetBinding->extension = asset->magic;
             assetBinding->version = asset->version;
@@ -762,7 +762,7 @@ void Pak_StubInvalidAssetBinds(PakFile_t* const pak, PakSegmentDescriptor_t* con
             assetBinding->headerSize = asset->headerSize;
             assetBinding->nativeClassSize = asset->headerSize;
             assetBinding->headerAlignment = pak->memoryData.pageHeaders[asset->headPtr.index].pageAlignment;
-            assetBinding->type = PakAssetBinding_t::STUB;
+            assetBinding->type = PakAssetBinding_s::STUB;
         }
 
         // this is dev only because it could spam a lot on older paks
@@ -784,14 +784,14 @@ void Pak_StubInvalidAssetBinds(PakFile_t* const pak, PakSegmentDescriptor_t* con
     }
 }
 
-bool Pak_StartLoadingPak(PakLoadedInfo_t* const loadedInfo)
+bool Pak_StartLoadingPak(PakLoadedInfo_s* const loadedInfo)
 {
-    PakFile_t* const pakFile = loadedInfo->pakFile;
+    PakFile_s* const pakFile = loadedInfo->pakFile;
 
     if (pakFile->memoryData.patchSrcSize && !Pak_ProcessPakFile(pakFile))
         return false;
 
-    PakSegmentDescriptor_t pakDescriptor = {};
+    PakSegmentDescriptor_s pakDescriptor = {};
 
     Pak_StubInvalidAssetBinds(pakFile, &pakDescriptor);
 
@@ -823,7 +823,7 @@ bool Pak_StartLoadingPak(PakLoadedInfo_t* const loadedInfo)
 
     Pak_CopyPagesToSegments(pakFile, loadedInfo, &pakDescriptor);
 
-    const PakFileHeader_t& pakHdr = pakFile->GetHeader();
+    const PakFileHeader_s& pakHdr = pakFile->GetHeader();
 
     if (Pak_StreamingEnabled())
         Pak_LoadStreamingData(loadedInfo);
@@ -833,12 +833,12 @@ bool Pak_StartLoadingPak(PakLoadedInfo_t* const loadedInfo)
 
     pakFile->dword14 = 1;
 
-    PakMemoryData_t& memoryData = pakFile->memoryData;
+    PakMemoryData_s& memoryData = pakFile->memoryData;
 
     memoryData.patchSrcSize = pakFile->memoryData.qword2D0 - patchDestOffset;
     memoryData.patchDstPtr = (char*)&pakHdr + patchDestOffset;
 
-    loadedInfo->status = EPakStatus::PAK_STATUS_LOAD_PAKHDR;
+    loadedInfo->status = PakStatus_e::PAK_STATUS_LOAD_PAKHDR;
 
     return true;
 }
diff --git a/r5dev/rtech/pak/pakparse.h b/r5dev/rtech/pak/pakparse.h
index 30a176fe..dc05407c 100644
--- a/r5dev/rtech/pak/pakparse.h
+++ b/r5dev/rtech/pak/pakparse.h
@@ -11,22 +11,22 @@
 inline PakHandle_t(*v_Pak_Initialize)(int mode);
 
 inline PakHandle_t(*v_Pak_LoadAsync)(const char* fileName, CAlignedMemAlloc* allocator, int nIdx, bool bUnk);
-inline EPakStatus(*v_Pak_WaitAsync)(PakHandle_t handle, void* finishCallback);
+inline PakStatus_e(*v_Pak_WaitAsync)(PakHandle_t handle, void* finishCallback);
 inline void(*v_Pak_UnloadAsync)(PakHandle_t handle);
 inline void(*v_Pak_RegisterAsset)(int, int, const char*, void*, void*, void*, void*, int, int, uint32_t, int, int);
 
-inline bool(*v_Pak_StartLoadingPak)(PakLoadedInfo_t* loadedInfo);
-inline bool(*v_Pak_ProcessPakFile)(PakFile_t* const pak);
-inline bool(*v_Pak_ProcessAssets)(PakLoadedInfo_t* pakInfo);
-inline void(*v_Pak_ResolveAssetRelations)(PakFile_t* const pak, const PakAsset_t* const asset);
+inline bool(*v_Pak_StartLoadingPak)(PakLoadedInfo_s* loadedInfo);
+inline bool(*v_Pak_ProcessPakFile)(PakFile_s* const pak);
+inline bool(*v_Pak_ProcessAssets)(PakLoadedInfo_s* pakInfo);
+inline void(*v_Pak_ResolveAssetRelations)(PakFile_s* const pak, const PakAsset_s* const asset);
 
-inline void (*v_Pak_RunAssetLoadingJobs)(PakFile_t* pak);
-inline void (*Pak_ProcessAssetRelationsAndResolveDependencies)(PakFile_t* pak_arg, PakAsset_t* asset_arg, unsigned int asset_idx_arg, unsigned int a4);
+inline void (*v_Pak_RunAssetLoadingJobs)(PakFile_s* pak);
+inline void (*Pak_ProcessAssetRelationsAndResolveDependencies)(PakFile_s* pak_arg, PakAsset_s* asset_arg, unsigned int asset_idx_arg, unsigned int a4);
 
-inline int  (*Pak_TrackAsset)(PakFile_t* const a1, PakAsset_t* a2);
+inline int  (*Pak_TrackAsset)(PakFile_s* const a1, PakAsset_s* a2);
 
 // TODO: name these!
-inline void (*sub_14043D870)(PakLoadedInfo_t* a1, int a2);
+inline void (*sub_14043D870)(PakLoadedInfo_s* a1, int a2);
 
 ///////////////////////////////////////////////////////////////////////////////
 class V_PakParse : public IDetour
diff --git a/r5dev/rtech/pak/pakpatch.cpp b/r5dev/rtech/pak/pakpatch.cpp
index 75075a14..55259520 100644
--- a/r5dev/rtech/pak/pakpatch.cpp
+++ b/r5dev/rtech/pak/pakpatch.cpp
@@ -6,7 +6,7 @@
 #include "rtech/ipakfile.h"
 #include "pakpatch.h"
 
-bool PATCH_CMD_0(PakFile_t* const pak, size_t* const numAvailableBytes)
+bool PATCH_CMD_0(PakFile_s* const pak, size_t* const numAvailableBytes)
 {
     unsigned __int64 m_numBytesToProcess_maybe; // r9
     unsigned __int64 v4; // rdi
@@ -83,7 +83,7 @@ bool PATCH_CMD_0(PakFile_t* const pak, size_t* const numAvailableBytes)
     return pak->memoryData.numBytesToProcess_maybe == 0;
 }
 
-bool PATCH_CMD_1(PakFile_t* const pak, size_t* const numAvailableBytes)
+bool PATCH_CMD_1(PakFile_s* const pak, size_t* const numAvailableBytes)
 {
     unsigned __int64 m_numBytesToProcess_maybe; // r8
     size_t v3; // r9
@@ -111,7 +111,7 @@ bool PATCH_CMD_1(PakFile_t* const pak, size_t* const numAvailableBytes)
     }
 }
 
-bool PATCH_CMD_2(PakFile_t* const pak, size_t* const numAvailableBytes)
+bool PATCH_CMD_2(PakFile_s* const pak, size_t* const numAvailableBytes)
 {
     NOTE_UNUSED(numAvailableBytes);
 
@@ -153,7 +153,7 @@ bool PATCH_CMD_2(PakFile_t* const pak, size_t* const numAvailableBytes)
     return pak->memoryData.numBytesToProcess_maybe == 0;
 }
 
-bool PATCH_CMD_3(PakFile_t* const pak, size_t* const numAvailableBytes)
+bool PATCH_CMD_3(PakFile_s* const pak, size_t* const numAvailableBytes)
 {
     size_t patchSrcSize = pak->memoryData.patchSrcSize;
 
@@ -172,7 +172,7 @@ bool PATCH_CMD_3(PakFile_t* const pak, size_t* const numAvailableBytes)
     return pak->memoryData.numBytesToProcess_maybe == 0;
 }
 
-bool PATCH_CMD_4_5(PakFile_t* const pak, size_t* const numAvailableBytes)
+bool PATCH_CMD_4_5(PakFile_s* const pak, size_t* const numAvailableBytes)
 {
     const size_t v2 = *numAvailableBytes;
     if (!v2)
@@ -188,7 +188,7 @@ bool PATCH_CMD_4_5(PakFile_t* const pak, size_t* const numAvailableBytes)
     return PATCH_CMD_0(pak, numAvailableBytes);
 }
 
-bool PATCH_CMD_6(PakFile_t* const pak, size_t* const numAvailableBytes)
+bool PATCH_CMD_6(PakFile_s* const pak, size_t* const numAvailableBytes)
 {
     const size_t v2 = *numAvailableBytes;
     size_t v3 = 2;
@@ -238,7 +238,7 @@ bool PATCH_CMD_6(PakFile_t* const pak, size_t* const numAvailableBytes)
     return false;
 }
 
-const PakPatchFuncs_t g_pakPatchApi
+const PakPatchFuncs_s g_pakPatchApi
 {
     PATCH_CMD_0,
     PATCH_CMD_1,
diff --git a/r5dev/rtech/pak/pakpatch.h b/r5dev/rtech/pak/pakpatch.h
index 287416f0..7b85f9b4 100644
--- a/r5dev/rtech/pak/pakpatch.h
+++ b/r5dev/rtech/pak/pakpatch.h
@@ -2,6 +2,6 @@
 #define RTECH_PATCHAPI_H
 #include "rtech/ipakfile.h"
 
-extern const PakPatchFuncs_t g_pakPatchApi;
+extern const PakPatchFuncs_s g_pakPatchApi;
 
 #endif // RTECH_PATCHAPI_H
diff --git a/r5dev/rtech/pak/pakstate.cpp b/r5dev/rtech/pak/pakstate.cpp
index 927683b3..a79653c3 100644
--- a/r5dev/rtech/pak/pakstate.cpp
+++ b/r5dev/rtech/pak/pakstate.cpp
@@ -24,9 +24,9 @@ static void Pak_ListPaks_f()
 
 	for (int16_t i = 0, n = g_pakGlobals->loadedPakCount; i < n; ++i)
 	{
-		const PakLoadedInfo_t& info = g_pakGlobals->loadedPaks[i];
+		const PakLoadedInfo_s& info = g_pakGlobals->loadedPaks[i];
 
-		if (info.status == EPakStatus::PAK_STATUS_FREED)
+		if (info.status == PakStatus_e::PAK_STATUS_FREED)
 			continue;
 
 		const char* szRpakStatus = Pak_StatusToString(info.status);
@@ -54,7 +54,7 @@ static void Pak_ListTypes_f()
 
 	for (int8_t i = 0; i < PAK_MAX_TRACKED_TYPES; ++i)
 	{
-		PakAssetBinding_t* type = &g_pakGlobals->assetBindings[i];
+		PakAssetBinding_s* type = &g_pakGlobals->assetBindings[i];
 
 		if (!type->description)
 			continue;
@@ -85,7 +85,7 @@ static void Pak_RequestUnload_f(const CCommand& args)
 	if (args.HasOnlyDigits(1))
 	{
 		const PakHandle_t pakHandle = atoi(args.Arg(1));
-		const PakLoadedInfo_t* const pakInfo = Pak_GetPakInfo(pakHandle);
+		const PakLoadedInfo_s* const pakInfo = Pak_GetPakInfo(pakHandle);
 
 		if (!pakInfo)
 		{
@@ -98,7 +98,7 @@ static void Pak_RequestUnload_f(const CCommand& args)
 	}
 	else
 	{
-		const PakLoadedInfo_t* const pakInfo = Pak_GetPakInfo(args.Arg(1));
+		const PakLoadedInfo_s* const pakInfo = Pak_GetPakInfo(args.Arg(1));
 		if (!pakInfo)
 		{
 			Warning(eDLL_T::RTECH, "Found no pak entry for specified name.\n");
@@ -136,7 +136,7 @@ static void Pak_Swap_f(const CCommand& args)
 	const char* pakName = nullptr;
 
 	PakHandle_t pakHandle = PAK_INVALID_HANDLE;
-	const PakLoadedInfo_t* pakInfo = nullptr;
+	const PakLoadedInfo_s* pakInfo = nullptr;
 
 	if (args.HasOnlyDigits(1))
 	{
@@ -168,7 +168,7 @@ static void Pak_Swap_f(const CCommand& args)
 	Msg(eDLL_T::RTECH, "Requested pak swap for handle '%d'\n", pakHandle);
 	g_pakLoadApi->UnloadAsync(pakHandle);
 
-	while (pakInfo->status != EPakStatus::PAK_STATUS_FREED) // Wait till this slot gets free'd.
+	while (pakInfo->status != PakStatus_e::PAK_STATUS_FREED) // Wait till this slot gets free'd.
 		std::this_thread::sleep_for(std::chrono::seconds(1));
 
 	g_pakLoadApi->LoadAsync(pakName, AlignedMemAlloc(), NULL, 0);
diff --git a/r5dev/rtech/pak/pakstate.h b/r5dev/rtech/pak/pakstate.h
index c2c08f28..09cc4e17 100644
--- a/r5dev/rtech/pak/pakstate.h
+++ b/r5dev/rtech/pak/pakstate.h
@@ -18,7 +18,7 @@ struct PakLoadFuncs_s
 	char unknown2[16];
 	void* Func7;
 	void* Func8;
-	EPakStatus(*WaitAsync)(PakHandle_t handle, void* finishCallback);
+	PakStatus_e(*WaitAsync)(PakHandle_t handle, void* finishCallback);
 	void* Func10;
 	void* Func11;
 	void* FindByGUID;
@@ -47,7 +47,7 @@ struct PakLoadFuncs_s
 	void* Func33;
 };
 
-inline PakGlobals_s* g_pakGlobals;
+inline PakGlobalState_s* g_pakGlobals;
 extern PakLoadFuncs_s* g_pakLoadApi;
 
 inline JobHelpCallback_t g_pPakFifoLockWrapper; // Pointer to functor that takes the global pak fifolock as argument.
@@ -72,7 +72,7 @@ class V_PakState : public IDetour
 	virtual void GetFun(void) const { }
 	virtual void GetVar(void) const
 	{
-		g_pakGlobals = g_GameDll.FindPatternSIMD("48 8D 1D ?? ?? ?? ?? 45 8D 5A 0E").ResolveRelativeAddressSelf(0x3, 0x7).RCast<PakGlobals_s*>();
+		g_pakGlobals = g_GameDll.FindPatternSIMD("48 8D 1D ?? ?? ?? ?? 45 8D 5A 0E").ResolveRelativeAddressSelf(0x3, 0x7).RCast<PakGlobalState_s*>();
 		g_pakLoadApi = CMemory(v_LauncherMain).Offset(0x820).FindPatternSelf("48 89").ResolveRelativeAddressSelf(0x3, 0x7).RCast<PakLoadFuncs_s*>();
 
 		const CMemory jtBase(JT_HelpWithAnything);
diff --git a/r5dev/rtech/pak/pakstream.cpp b/r5dev/rtech/pak/pakstream.cpp
index f530c722..b9f9e948 100644
--- a/r5dev/rtech/pak/pakstream.cpp
+++ b/r5dev/rtech/pak/pakstream.cpp
@@ -45,12 +45,12 @@ static bool Pak_OptionalStreamingDataDownloaded()
 //-----------------------------------------------------------------------------
 // opens all associated streaming assets for this pak
 //-----------------------------------------------------------------------------
-void Pak_OpenAssociatedStreamingFiles(PakLoadedInfo_t* const loadedInfo, PakLoadedInfo_t::StreamingInfo_t& streamInfo,
-    const uint16_t fileNamesBufSize, const EPakStreamSet set)
+void Pak_OpenAssociatedStreamingFiles(PakLoadedInfo_s* const loadedInfo, PakLoadedInfo_s::StreamingInfo_t& streamInfo,
+    const uint16_t fileNamesBufSize, const PakStreamSet_e set)
 {
     assert(set < STREAMING_SET_COUNT);
 
-    const PakMemoryData_t& memoryData = loadedInfo->pakFile->memoryData;
+    const PakMemoryData_s& memoryData = loadedInfo->pakFile->memoryData;
     uint16_t numStreamFiles = 0;
 
     // load all streaming sets
@@ -83,7 +83,7 @@ void Pak_OpenAssociatedStreamingFiles(PakLoadedInfo_t* const loadedInfo, PakLoad
 //-----------------------------------------------------------------------------
 // allocates the pak string to be used for embedded streaming data
 //-----------------------------------------------------------------------------
-void Pak_EnableEmbeddedStreamingData(PakLoadedInfo_t* const loadedInfo, PakLoadedInfo_t::StreamingInfo_t& streamInfo)
+void Pak_EnableEmbeddedStreamingData(PakLoadedInfo_s* const loadedInfo, PakLoadedInfo_s::StreamingInfo_t& streamInfo)
 {
     const char* const baseName = V_UnqualifiedFileName(loadedInfo->fileName);
     const size_t baseNameLen = strlen(baseName);
@@ -113,13 +113,13 @@ void Pak_EnableEmbeddedStreamingData(PakLoadedInfo_t* const loadedInfo, PakLoade
 //-----------------------------------------------------------------------------
 // parse and open all streaming files
 //-----------------------------------------------------------------------------
-void Pak_LoadStreamingData(PakLoadedInfo_t* const loadedInfo)
+void Pak_LoadStreamingData(PakLoadedInfo_s* const loadedInfo)
 {
-    const PakFileHeader_t& pakHeader = loadedInfo->pakFile->GetHeader();
+    const PakFileHeader_s& pakHeader = loadedInfo->pakFile->GetHeader();
 
     for (int i = 0; i < STREAMING_SET_COUNT; i++)
     {
-        PakLoadedInfo_t::StreamingInfo_t& streamInfo = loadedInfo->streamInfo[i];
+        PakLoadedInfo_s::StreamingInfo_t& streamInfo = loadedInfo->streamInfo[i];
         streamInfo.Reset();
 
         const bool optional = (i == STREAMING_SET_OPTIONAL);
@@ -141,7 +141,7 @@ void Pak_LoadStreamingData(PakLoadedInfo_t* const loadedInfo)
             // external streaming files; mistake while building the pak?
             assert(!embeddedStreamingDataSize);
 
-            Pak_OpenAssociatedStreamingFiles(loadedInfo, streamInfo, filesBufLen, EPakStreamSet(i));
+            Pak_OpenAssociatedStreamingFiles(loadedInfo, streamInfo, filesBufLen, PakStreamSet_e(i));
         }
         else if (embeddedStreamingDataSize > 0)
         {
diff --git a/r5dev/rtech/pak/pakstream.h b/r5dev/rtech/pak/pakstream.h
index 7667acd2..5b3e2bc4 100644
--- a/r5dev/rtech/pak/pakstream.h
+++ b/r5dev/rtech/pak/pakstream.h
@@ -3,11 +3,11 @@
 #include "rtech/ipakfile.h"
 #include "pakstate.h"
 
-extern void Pak_OpenAssociatedStreamingFiles(PakLoadedInfo_t* const loadedInfo, PakLoadedInfo_t::StreamingInfo_t& streamInfo,
-    const uint16_t fileNamesBufSize, const EPakStreamSet set);
+extern void Pak_OpenAssociatedStreamingFiles(PakLoadedInfo_s* const loadedInfo, PakLoadedInfo_s::StreamingInfo_t& streamInfo,
+    const uint16_t fileNamesBufSize, const PakStreamSet_e set);
 
-extern void Pak_EnableEmbeddedStreamingData(PakLoadedInfo_t* const loadedInfo, PakLoadedInfo_t::StreamingInfo_t& streamInfo);
-extern void Pak_LoadStreamingData(PakLoadedInfo_t* const loadedInfo);
+extern void Pak_EnableEmbeddedStreamingData(PakLoadedInfo_s* const loadedInfo, PakLoadedInfo_s::StreamingInfo_t& streamInfo);
+extern void Pak_LoadStreamingData(PakLoadedInfo_s* const loadedInfo);
 
 // the current download progress of optional streaming assets
 inline float* g_pStreamingDownloadProgress = nullptr;
diff --git a/r5dev/rtech/pak/paktools.cpp b/r5dev/rtech/pak/paktools.cpp
index 0f850314..7ed1e409 100644
--- a/r5dev/rtech/pak/paktools.cpp
+++ b/r5dev/rtech/pak/paktools.cpp
@@ -77,26 +77,26 @@ int Pak_FileExists(const char* const pakFilePath)
 //-----------------------------------------------------------------------------
 // returns pak status as string
 //-----------------------------------------------------------------------------
-const char* Pak_StatusToString(const EPakStatus status)
+const char* Pak_StatusToString(const PakStatus_e status)
 {
 	switch (status)
 	{
-	case EPakStatus::PAK_STATUS_FREED:                  return "PAK_STATUS_FREED";
-	case EPakStatus::PAK_STATUS_LOAD_PENDING:           return "PAK_STATUS_LOAD_PENDING";
-	case EPakStatus::PAK_STATUS_REPAK_RUNNING:          return "PAK_STATUS_REPAK_RUNNING";
-	case EPakStatus::PAK_STATUS_REPAK_DONE:             return "PAK_STATUS_REPAK_DONE";
-	case EPakStatus::PAK_STATUS_LOAD_STARTING:          return "PAK_STATUS_LOAD_STARTING";
-	case EPakStatus::PAK_STATUS_LOAD_PAKHDR:            return "PAK_STATUS_LOAD_PAKHDR";
-	case EPakStatus::PAK_STATUS_LOAD_PATCH_INIT:        return "PAK_STATUS_LOAD_PATCH_INIT";
-	case EPakStatus::PAK_STATUS_LOAD_PATCH_EDIT_STREAM: return "PAK_STATUS_LOAD_PATCH_EDIT_STREAM";
-	case EPakStatus::PAK_STATUS_LOAD_ASSETS:            return "PAK_STATUS_LOAD_ASSETS";
-	case EPakStatus::PAK_STATUS_LOADED:                 return "PAK_STATUS_LOADED";
-	case EPakStatus::PAK_STATUS_UNLOAD_PENDING:         return "PAK_STATUS_UNLOAD_PENDING";
-	case EPakStatus::PAK_STATUS_FREE_PENDING:           return "PAK_STATUS_FREE_PENDING";
-	case EPakStatus::PAK_STATUS_CANCELING:              return "PAK_STATUS_CANCELING";
-	case EPakStatus::PAK_STATUS_ERROR:                  return "PAK_STATUS_ERROR";
-	case EPakStatus::PAK_STATUS_INVALID_PAKHANDLE:      return "PAK_STATUS_INVALID_PAKHANDLE";
-	case EPakStatus::PAK_STATUS_BUSY:                   return "PAK_STATUS_BUSY";
+	case PakStatus_e::PAK_STATUS_FREED:                  return "PAK_STATUS_FREED";
+	case PakStatus_e::PAK_STATUS_LOAD_PENDING:           return "PAK_STATUS_LOAD_PENDING";
+	case PakStatus_e::PAK_STATUS_REPAK_RUNNING:          return "PAK_STATUS_REPAK_RUNNING";
+	case PakStatus_e::PAK_STATUS_REPAK_DONE:             return "PAK_STATUS_REPAK_DONE";
+	case PakStatus_e::PAK_STATUS_LOAD_STARTING:          return "PAK_STATUS_LOAD_STARTING";
+	case PakStatus_e::PAK_STATUS_LOAD_PAKHDR:            return "PAK_STATUS_LOAD_PAKHDR";
+	case PakStatus_e::PAK_STATUS_LOAD_PATCH_INIT:        return "PAK_STATUS_LOAD_PATCH_INIT";
+	case PakStatus_e::PAK_STATUS_LOAD_PATCH_EDIT_STREAM: return "PAK_STATUS_LOAD_PATCH_EDIT_STREAM";
+	case PakStatus_e::PAK_STATUS_LOAD_ASSETS:            return "PAK_STATUS_LOAD_ASSETS";
+	case PakStatus_e::PAK_STATUS_LOADED:                 return "PAK_STATUS_LOADED";
+	case PakStatus_e::PAK_STATUS_UNLOAD_PENDING:         return "PAK_STATUS_UNLOAD_PENDING";
+	case PakStatus_e::PAK_STATUS_FREE_PENDING:           return "PAK_STATUS_FREE_PENDING";
+	case PakStatus_e::PAK_STATUS_CANCELING:              return "PAK_STATUS_CANCELING";
+	case PakStatus_e::PAK_STATUS_ERROR:                  return "PAK_STATUS_ERROR";
+	case PakStatus_e::PAK_STATUS_INVALID_PAKHANDLE:      return "PAK_STATUS_INVALID_PAKHANDLE";
+	case PakStatus_e::PAK_STATUS_BUSY:                   return "PAK_STATUS_BUSY";
 	default:                                            return "PAK_STATUS_UNKNOWN";
 	}
 }
@@ -104,12 +104,12 @@ const char* Pak_StatusToString(const EPakStatus status)
 //-----------------------------------------------------------------------------
 // returns pak decoder as string
 //-----------------------------------------------------------------------------
-const char* Pak_DecoderToString(const EPakDecodeMode mode)
+const char* Pak_DecoderToString(const PakDecodeMode_e mode)
 {
 	switch (mode)
 	{
-	case EPakDecodeMode::MODE_RTECH: return "RTech";
-	case EPakDecodeMode::MODE_ZSTD: return "ZStd";
+	case PakDecodeMode_e::MODE_RTECH: return "RTech";
+	case PakDecodeMode_e::MODE_ZSTD: return "ZStd";
 	}
 
 	UNREACHABLE();
@@ -253,7 +253,7 @@ PakGuid_t Pak_StringToGuid(const char* const string)
 //-----------------------------------------------------------------------------
 // gets information about loaded pak file via pak id
 //-----------------------------------------------------------------------------
-PakLoadedInfo_t* Pak_GetPakInfo(const PakHandle_t pakId)
+PakLoadedInfo_s* Pak_GetPakInfo(const PakHandle_t pakId)
 {
 	return &g_pakGlobals->loadedPaks[pakId & PAK_MAX_LOADED_PAKS_MASK];
 }
@@ -261,11 +261,11 @@ PakLoadedInfo_t* Pak_GetPakInfo(const PakHandle_t pakId)
 //-----------------------------------------------------------------------------
 // gets information about loaded pak file via pak name
 //-----------------------------------------------------------------------------
-const PakLoadedInfo_t* Pak_GetPakInfo(const char* const pakName)
+const PakLoadedInfo_s* Pak_GetPakInfo(const char* const pakName)
 {
 	for (int16_t i = 0; i < g_pakGlobals->loadedPakCount; ++i)
 	{
-		const PakLoadedInfo_t* const info = &g_pakGlobals->loadedPaks[i];
+		const PakLoadedInfo_s* const info = &g_pakGlobals->loadedPaks[i];
 		if (!info)
 			continue;
 
@@ -285,27 +285,27 @@ const PakLoadedInfo_t* Pak_GetPakInfo(const char* const pakName)
 //-----------------------------------------------------------------------------
 // returns a pointer to the patch data header
 //-----------------------------------------------------------------------------
-PakPatchDataHeader_t* Pak_GetPatchDataHeader(PakFileHeader_t* const pakHeader)
+PakPatchDataHeader_s* Pak_GetPatchDataHeader(PakFileHeader_s* const pakHeader)
 {
 	// shouldn't be called if the pak doesn1't have patches!
 	assert(pakHeader->patchIndex > 0);
-	return reinterpret_cast<PakPatchDataHeader_t*>(reinterpret_cast<uint8_t* const>(pakHeader) + sizeof(PakFileHeader_t));
+	return reinterpret_cast<PakPatchDataHeader_s*>(reinterpret_cast<uint8_t* const>(pakHeader) + sizeof(PakFileHeader_s));
 }
 
 //-----------------------------------------------------------------------------
 // returns a pointer to the patch file header
 //-----------------------------------------------------------------------------
-PakPatchFileHeader_t* Pak_GetPatchFileHeader(PakFileHeader_t* const pakHeader, const int index)
+PakPatchFileHeader_s* Pak_GetPatchFileHeader(PakFileHeader_s* const pakHeader, const int index)
 {
 	assert(pakHeader->patchIndex > 0 && index < pakHeader->patchIndex);
 	uint8_t* address = reinterpret_cast<uint8_t* const>(pakHeader);
 
 	// skip the file header
-	address += sizeof(PakFileHeader_t);
+	address += sizeof(PakFileHeader_s);
 
 	// skip the patch data header, the patch file headers start from there
-	address += sizeof(PakPatchDataHeader_t);
-	PakPatchFileHeader_t* const patchHeaders = reinterpret_cast<PakPatchFileHeader_t* const>(address);
+	address += sizeof(PakPatchDataHeader_s);
+	PakPatchFileHeader_s* const patchHeaders = reinterpret_cast<PakPatchFileHeader_s* const>(address);
 
 	return &patchHeaders[index];
 }
@@ -313,13 +313,13 @@ PakPatchFileHeader_t* Pak_GetPatchFileHeader(PakFileHeader_t* const pakHeader, c
 //-----------------------------------------------------------------------------
 // returns the patch number belonging to the index provided
 //-----------------------------------------------------------------------------
-short Pak_GetPatchNumberForIndex(PakFileHeader_t* const pakHeader, const int index)
+short Pak_GetPatchNumberForIndex(PakFileHeader_s* const pakHeader, const int index)
 {
 	assert(pakHeader->patchIndex > 0 && index < pakHeader->patchIndex);
 	const uint8_t* patchHeader = reinterpret_cast<const uint8_t*>(Pak_GetPatchFileHeader(pakHeader, pakHeader->patchIndex - 1));
 
 	// skip the last patch file header, the patch number start from there
-	patchHeader += sizeof(PakPatchFileHeader_t);
+	patchHeader += sizeof(PakPatchFileHeader_s);
 	const short* patchNumber = reinterpret_cast<const short*>(patchHeader);
 
 	return patchNumber[index];
@@ -347,7 +347,7 @@ bool Pak_UpdatePatchHeaders(uint8_t* const inBuf, const char* const outPakFile)
 
 	// NOTE: we modify the in buffer as the patch headers belong to the
 	// compressed section
-	PakFileHeader_t* const inHeader = reinterpret_cast<PakFileHeader_t* const>(inBuf);
+	PakFileHeader_s* const inHeader = reinterpret_cast<PakFileHeader_s* const>(inBuf);
 
 	// update each patch header
 	for (uint16_t i = 0; i < inHeader->patchIndex; i++)
@@ -371,13 +371,13 @@ bool Pak_UpdatePatchHeaders(uint8_t* const inBuf, const char* const outPakFile)
 		const size_t fileSize = inPatch.GetSize();
 
 		// pak appears truncated
-		if (fileSize <= sizeof(PakFileHeader_t))
+		if (fileSize <= sizeof(PakFileHeader_s))
 			return false;
 
 		DevMsg(eDLL_T::RTECH, "%s: updating patch header for pak '%s', new size = %zu\n",
 			__FUNCTION__, patchFile, fileSize);
 
-		PakPatchFileHeader_t* const patchHeader = Pak_GetPatchFileHeader(inHeader, i);
+		PakPatchFileHeader_s* const patchHeader = Pak_GetPatchFileHeader(inHeader, i);
 		patchHeader->compressedSize = fileSize;
 	}
 
@@ -387,7 +387,7 @@ bool Pak_UpdatePatchHeaders(uint8_t* const inBuf, const char* const outPakFile)
 //-----------------------------------------------------------------------------
 // prints the pak header details to the console
 //-----------------------------------------------------------------------------
-void Pak_ShowHeaderDetails(const PakFileHeader_t* const pakHeader)
+void Pak_ShowHeaderDetails(const PakFileHeader_s* const pakHeader)
 {
 	SYSTEMTIME systemTime;
 	FileTimeToSystemTime(&pakHeader->fileTime, &systemTime);
diff --git a/r5dev/rtech/pak/paktools.h b/r5dev/rtech/pak/paktools.h
index cd9e5780..becc39a2 100644
--- a/r5dev/rtech/pak/paktools.h
+++ b/r5dev/rtech/pak/paktools.h
@@ -12,20 +12,20 @@ extern bool Pak_FileOverrideExists(const char* const pakFilePath, char* const ou
 
 extern int Pak_FileExists(const char* const pakFilePath);
 
-extern const char* Pak_StatusToString(const EPakStatus status);
-const char* Pak_DecoderToString(const EPakDecodeMode mode);
+extern const char* Pak_StatusToString(const PakStatus_e status);
+const char* Pak_DecoderToString(const PakDecodeMode_e mode);
 
 extern PakGuid_t Pak_StringToGuid(const char* const string);
 
-extern PakLoadedInfo_t* Pak_GetPakInfo(const PakHandle_t pakId);
-extern const PakLoadedInfo_t* Pak_GetPakInfo(const char* const pakName);
+extern PakLoadedInfo_s* Pak_GetPakInfo(const PakHandle_t pakId);
+extern const PakLoadedInfo_s* Pak_GetPakInfo(const char* const pakName);
 
-extern PakPatchDataHeader_t* Pak_GetPatchDataHeader(PakFileHeader_t* const pakHeader);
-extern PakPatchFileHeader_t* Pak_GetPatchFileHeader(PakFileHeader_t* const pakHeader, const int index);
-extern short Pak_GetPatchNumberForIndex(PakFileHeader_t* const pakHeader, const int index);
+extern PakPatchDataHeader_s* Pak_GetPatchDataHeader(PakFileHeader_s* const pakHeader);
+extern PakPatchFileHeader_s* Pak_GetPatchFileHeader(PakFileHeader_s* const pakHeader, const int index);
+extern short Pak_GetPatchNumberForIndex(PakFileHeader_s* const pakHeader, const int index);
 
 extern bool Pak_UpdatePatchHeaders(uint8_t* const inBuf, const char* const outPakFile);
 
-extern void Pak_ShowHeaderDetails(const PakFileHeader_t* const pakHeader);
+extern void Pak_ShowHeaderDetails(const PakFileHeader_s* const pakHeader);
 
 #endif // !RTECH_PAKTOOLS_H