diff --git a/external/ircolib/file.hpp b/external/ircolib/file.hpp
index c4a7b8f..9d04f7c 100644
--- a/external/ircolib/file.hpp
+++ b/external/ircolib/file.hpp
@@ -4,9 +4,8 @@
 #include <vector>
 #include <filesystem>
 
-namespace fs = std::filesystem;
-
 namespace ircolib {
+namespace fs = std::filesystem;
 static inline std::vector<u8> read_file_binary(const std::string &path) {
     std::ifstream file(path, std::ios::binary);
     return {std::istreambuf_iterator{file}, {}};
@@ -17,19 +16,19 @@ static inline void write_file_binary(const std::vector<u8> &data, const std::str
     std::copy(data.begin(), data.end(), std::ostreambuf_iterator{file});
 }
 
-static inline void write_file_binary(const u8 *data, const size_t size, const std::string &path) {
+static inline void write_file_binary(const u8 *data, const u32 size, const std::string &path) {
     FILE *out = fopen(path.c_str(), "wb");
     fwrite(data, size, 1, out);
     fclose(out);
 }
 
-template <size_t Size>
+template <u32 Size>
 static inline void write_file_binary(const std::array<u8, Size> &data, const std::string &path) {
     std::ofstream file(path, std::ios::binary);
     std::copy(data.begin(), data.end(), std::ostreambuf_iterator{file});
 }
 
-static inline size_t next_pow2(size_t num) {
+static inline u32 next_pow2(u32 num) {
     // Taken from "Bit Twiddling Hacks" by Sean Anderson:
     // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
     --num;
diff --git a/external/ircolib/mem_access.hpp b/external/ircolib/mem_access.hpp
index 8f38fc1..e9158df 100644
--- a/external/ircolib/mem_access.hpp
+++ b/external/ircolib/mem_access.hpp
@@ -35,14 +35,14 @@ template <typename T>
 static constexpr inline T read_access(const u8 *data, const u32 index);
 template <typename T>
 static constexpr inline T read_access(const std::vector<u8> &data, const u32 index);
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline T read_access(const std::array<u8, Size> &data, const u32 index);
 
 template <typename T>
 static constexpr inline void write_access(u8 *data, const u32 index, const T val);
 template <typename T>
 static constexpr inline void write_access(std::vector<u8> &data, const u32 index, const T val);
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const T val);
 
 template <>
@@ -70,19 +70,19 @@ static constexpr inline T read_access(const std::vector<u8> &data, const u32 ind
     return *reinterpret_cast<const T *>(&data[index]);
 }
 
-template <size_t Size>
+template <u32 Size>
 constexpr inline u64 read_access(const std::array<u8, Size> &data, const u32 index) {
     u32 hi = *reinterpret_cast<const u32 *>(&data[index + 0]);
     u32 lo = *reinterpret_cast<const u32 *>(&data[index + 4]);
     return static_cast<u64>(hi) << 32 | static_cast<u64>(lo);
 }
 
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline T read_access(const std::array<u8, Size> &data, const u32 index) {
     return *reinterpret_cast<const T *>(&data[index]);
 }
 
-template <size_t Size>
+template <u32 Size>
 constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const u64 val) {
     const u32 hi = val >> 32;
     const u32 lo = val;
@@ -91,7 +91,7 @@ constexpr inline void write_access(std::array<u8, Size> &data, const u32 index,
     *reinterpret_cast<u32 *>(&data[index + 4]) = lo;
 }
 
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const T val) {
     *reinterpret_cast<T *>(&data[index]) = val;
 }
@@ -126,34 +126,34 @@ static constexpr inline void write_access(u8 *data, const u32 index, const T val
 
 template <typename T>
 static constexpr inline void swap_buffer(std::vector<u8> &data) {
-    for (size_t i = 0; i < data.size(); i += sizeof(T)) {
+    for (u32 i = 0; i < data.size(); i += sizeof(T)) {
         const T original = *reinterpret_cast<T *>(&data[i]);
         *reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
     }
 }
 
-template <typename T, size_t Size>
+template <typename T, u32 Size>
 static constexpr inline void swap_buffer(std::array<u8, Size> &data) {
-    for (size_t i = 0; i < data.size(); i += sizeof(T)) {
+    for (u32 i = 0; i < data.size(); i += sizeof(T)) {
         const T original = *reinterpret_cast<T *>(&data[i]);
         *reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
     }
 }
 
 template <typename T>
-static constexpr inline void swap_buffer(u8 *data, size_t size) {
-    for (size_t i = 0; i < size; i += sizeof(T)) {
+static constexpr inline void swap_buffer(u8 *data, u32 size) {
+    for (u32 i = 0; i < size; i += sizeof(T)) {
         const T original = *reinterpret_cast<T *>(&data[i]);
         *reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
     }
 }
 
 #ifdef _WIN32
-inline void *aligned_alloc(const size_t alignment, const size_t size) { return _aligned_malloc(size, alignment); }
+inline void *aligned_alloc(const u32 alignment, const u32 size) { return _aligned_malloc(size, alignment); }
 
 inline void aligned_free(void *ptr) { _aligned_free(ptr); }
 #else
-inline void *aligned_alloc(const size_t alignment, const size_t size) { return std::aligned_alloc(alignment, size); }
+inline void *aligned_alloc(const u32 alignment, const u32 size) { return std::aligned_alloc(alignment, size); }
 
 inline void aligned_free(void *ptr) { std::free(ptr); }
 #endif
diff --git a/external/ircolib/types.hpp b/external/ircolib/types.hpp
index 728b9e6..7831014 100644
--- a/external/ircolib/types.hpp
+++ b/external/ircolib/types.hpp
@@ -1,6 +1,5 @@
 #pragma once
 #include <cstdint>
-#include <cstddef>
 
 namespace ircolib {
 using u8 = uint8_t;
@@ -12,28 +11,28 @@ using s16 = int16_t;
 using s32 = int32_t;
 using s64 = int64_t;
 
-template <typename T, std::size_t bit>
+template <typename T, u32 bit>
 static constexpr bool is_bit_set(const T &val) {
     return val & (1 << bit);
 }
 
-template <typename T, std::size_t bit>
+template <typename T, u32 bit>
 static constexpr void set_bit(T &val) {
     val |= 1 << bit;
 }
 
 template <typename T>
-inline bool is_bit_set(const T &val, const std::size_t &bit) {
+inline bool is_bit_set(const T &val, const u32 &bit) {
     return val & (1 << bit);
 }
 
 template <typename T>
-inline void set_bit(T &val, const std::size_t &bit) {
+inline void set_bit(T &val, const u32 &bit) {
     val |= 1 << bit;
 }
 
 template <typename T>
-inline void clear_bit(T &val, const std::size_t &bit) {
+inline void clear_bit(T &val, const u32 &bit) {
     val &= ~(1 << bit);
 }
 } // namespace ircolib