diff --git a/include/PICA/float_types.hpp b/include/PICA/float_types.hpp
index 3012ac74..fcc92917 100644
--- a/include/PICA/float_types.hpp
+++ b/include/PICA/float_types.hpp
@@ -6,156 +6,125 @@
 
 #include <cmath>
 #include <cstring>
+
 #include "helpers.hpp"
 
 namespace Floats {
-    /**
-     * Template class for converting arbitrary Pica float types to IEEE 754 32-bit single-precision
-     * floating point.
-     *
-     * When decoding, format is as follows:
-     *  - The first `M` bits are the mantissa
-     *  - The next `E` bits are the exponent
-     *  - The last bit is the sign bit
-     *
-     * @todo Verify on HW if this conversion is sufficiently accurate.
-     */
-    template <unsigned M, unsigned E>
-    struct Float {
-    public:
-        static Float<M, E> fromFloat32(float val) {
-            Float<M, E> ret;
-            ret.value = val;
-            return ret;
-        }
+	/**
+	 * Template class for converting arbitrary Pica float types to IEEE 754 32-bit single-precision
+	 * floating point.
+	 *
+	 * When decoding, format is as follows:
+	 *  - The first `M` bits are the mantissa
+	 *  - The next `E` bits are the exponent
+	 *  - The last bit is the sign bit
+	 *
+	 * @todo Verify on HW if this conversion is sufficiently accurate.
+	 */
+	template <unsigned M, unsigned E>
+	struct Float {
+	  public:
+		static Float<M, E> fromFloat32(float val) {
+			Float<M, E> ret;
+			ret.value = val;
+			return ret;
+		}
 
-        static Float<M, E> fromRaw(u32 hex) {
-            Float<M, E> res;
+		static Float<M, E> fromRaw(u32 hex) {
+			Float<M, E> res;
 
-            const int width = M + E + 1;
-            const int bias = 128 - (1 << (E - 1));
-            int exponent = (hex >> M) & ((1 << E) - 1);
-            const unsigned mantissa = hex & ((1 << M) - 1);
-            const unsigned sign = (hex >> (E + M)) << 31;
+			const int width = M + E + 1;
+			const int bias = 128 - (1 << (E - 1));
+			int exponent = (hex >> M) & ((1 << E) - 1);
+			const unsigned mantissa = hex & ((1 << M) - 1);
+			const unsigned sign = (hex >> (E + M)) << 31;
 
-            if (hex & ((1 << (width - 1)) - 1)) {
-                if (exponent == (1 << E) - 1)
-                    exponent = 255;
-                else
-                    exponent += bias;
-                hex = sign | (mantissa << (23 - M)) | (exponent << 23);
-            }
-            else {
-                hex = sign;
-            }
+			if (hex & ((1 << (width - 1)) - 1)) {
+				if (exponent == (1 << E) - 1)
+					exponent = 255;
+				else
+					exponent += bias;
+				hex = sign | (mantissa << (23 - M)) | (exponent << 23);
+			} else {
+				hex = sign;
+			}
 
-            std::memcpy(&res.value, &hex, sizeof(float));
+			std::memcpy(&res.value, &hex, sizeof(float));
 
-            return res;
-        }
+			return res;
+		}
 
-        static Float<M, E> zero() {
-            return fromFloat32(0.f);
-        }
+		static Float<M, E> zero() { return fromFloat32(0.f); }
 
-        // Not recommended for anything but logging
-        float toFloat32() const {
-            return value;
-        }
+		// Not recommended for anything but logging
+		float toFloat32() const { return value; }
 
-        double toFloat64() const {
-            return static_cast<double>(value);
-        }
+		double toFloat64() const { return static_cast<double>(value); }
 
-        operator float() {
-            return toFloat32();
-        }
+		operator float() { return toFloat32(); }
 
-        operator double() {
-            return toFloat64();
-        }
+		operator double() { return toFloat64(); }
 
-        Float<M, E> operator*(const Float<M, E>& flt) const {
-            float result = value * flt.toFloat32();
-            // PICA gives 0 instead of NaN when multiplying by inf
-            if (std::isnan(result))
-                if (!std::isnan(value) && !std::isnan(flt.toFloat32()))
-                    result = 0.f;
-            return Float<M, E>::fromFloat32(result);
-        }
+		Float<M, E> operator*(const Float<M, E>& flt) const {
+			float result = value * flt.toFloat32();
+			// PICA gives 0 instead of NaN when multiplying by inf
+			if (std::isnan(result))
+				if (!std::isnan(value) && !std::isnan(flt.toFloat32())) result = 0.f;
+			return Float<M, E>::fromFloat32(result);
+		}
 
-        Float<M, E> operator/(const Float<M, E>& flt) const {
-            return Float<M, E>::fromFloat32(toFloat32() / flt.toFloat32());
-        }
+		Float<M, E> operator/(const Float<M, E>& flt) const { return Float<M, E>::fromFloat32(toFloat32() / flt.toFloat32()); }
 
-        Float<M, E> operator+(const Float<M, E>& flt) const {
-            return Float<M, E>::fromFloat32(toFloat32() + flt.toFloat32());
-        }
+		Float<M, E> operator+(const Float<M, E>& flt) const { return Float<M, E>::fromFloat32(toFloat32() + flt.toFloat32()); }
 
-        Float<M, E> operator-(const Float<M, E>& flt) const {
-            return Float<M, E>::fromFloat32(toFloat32() - flt.toFloat32());
-        }
+		Float<M, E> operator-(const Float<M, E>& flt) const { return Float<M, E>::fromFloat32(toFloat32() - flt.toFloat32()); }
 
-        Float<M, E>& operator*=(const Float<M, E>& flt) {
-            value = operator*(flt).value;
-            return *this;
-        }
+		Float<M, E>& operator*=(const Float<M, E>& flt) {
+			value = operator*(flt).value;
+			return *this;
+		}
 
-        Float<M, E>& operator/=(const Float<M, E>& flt) {
-            value /= flt.toFloat32();
-            return *this;
-        }
+		Float<M, E>& operator/=(const Float<M, E>& flt) {
+			value /= flt.toFloat32();
+			return *this;
+		}
 
-        Float<M, E>& operator+=(const Float<M, E>& flt) {
-            value += flt.toFloat32();
-            return *this;
-        }
+		Float<M, E>& operator+=(const Float<M, E>& flt) {
+			value += flt.toFloat32();
+			return *this;
+		}
 
-        Float<M, E>& operator-=(const Float<M, E>& flt) {
-            value -= flt.toFloat32();
-            return *this;
-        }
+		Float<M, E>& operator-=(const Float<M, E>& flt) {
+			value -= flt.toFloat32();
+			return *this;
+		}
 
-        Float<M, E> operator-() const {
-            return Float<M, E>::fromFloat32(-toFloat32());
-        }
+		Float<M, E> operator-() const { return Float<M, E>::fromFloat32(-toFloat32()); }
 
-        bool operator<(const Float<M, E>& flt) const {
-            return toFloat32() < flt.toFloat32();
-        }
+		bool operator<(const Float<M, E>& flt) const { return toFloat32() < flt.toFloat32(); }
 
-        bool operator>(const Float<M, E>& flt) const {
-            return toFloat32() > flt.toFloat32();
-        }
+		bool operator>(const Float<M, E>& flt) const { return toFloat32() > flt.toFloat32(); }
 
-        bool operator>=(const Float<M, E>& flt) const {
-            return toFloat32() >= flt.toFloat32();
-        }
+		bool operator>=(const Float<M, E>& flt) const { return toFloat32() >= flt.toFloat32(); }
 
-        bool operator<=(const Float<M, E>& flt) const {
-            return toFloat32() <= flt.toFloat32();
-        }
+		bool operator<=(const Float<M, E>& flt) const { return toFloat32() <= flt.toFloat32(); }
 
-        bool operator==(const Float<M, E>& flt) const {
-            return toFloat32() == flt.toFloat32();
-        }
+		bool operator==(const Float<M, E>& flt) const { return toFloat32() == flt.toFloat32(); }
 
-        bool operator!=(const Float<M, E>& flt) const {
-            return toFloat32() != flt.toFloat32();
-        }
+		bool operator!=(const Float<M, E>& flt) const { return toFloat32() != flt.toFloat32(); }
 
-    private:
-        static constexpr unsigned MASK = (1 << (M + E + 1)) - 1;
-        static constexpr unsigned MANTISSA_MASK = (1 << M) - 1;
-        static constexpr unsigned EXPONENT_MASK = (1 << E) - 1;
+	  private:
+		static constexpr unsigned MASK = (1 << (M + E + 1)) - 1;
+		static constexpr unsigned MANTISSA_MASK = (1 << M) - 1;
+		static constexpr unsigned EXPONENT_MASK = (1 << E) - 1;
 
-        // Stored as a regular float, merely for convenience
-        // TODO: Perform proper arithmetic on this!
-        float value;
-    };
+		// Stored as a regular float, merely for convenience
+		// TODO: Perform proper arithmetic on this!
+		float value;
+	};
 
-    using f24 = Float<16, 7>;
-    using f20 = Float<12, 7>;
-    using f16 = Float<10, 5>;
+	using f24 = Float<16, 7>;
+	using f20 = Float<12, 7>;
+	using f16 = Float<10, 5>;
 
-} // namespace Floats
+}  // namespace Floats
diff --git a/include/PICA/shader.hpp b/include/PICA/shader.hpp
index 1040d2ff..3ef11114 100644
--- a/include/PICA/shader.hpp
+++ b/include/PICA/shader.hpp
@@ -107,7 +107,7 @@ class PICAShader {
 	alignas(16) std::array<vec4f, 16> inputs;           // Attributes passed to the shader
 	alignas(16) std::array<vec4f, 16> outputs;
 	alignas(16) vec4f dummy = vec4f({f24::zero(), f24::zero(), f24::zero(), f24::zero()});  // Dummy register used by the JIT
-	
+
 	// We use a hashmap for matching 3DS shaders to their equivalent compiled code in our shader cache in the shader JIT
 	// We choose our hash type to be a 64-bit integer by default, as the collision chance is very tiny and generating it is decently optimal
 	// Ideally we want to be able to support multiple different types of hash depending on compilation settings, but let's get this working first
@@ -234,7 +234,7 @@ class PICAShader {
 
   public:
 	static constexpr size_t maxInstructionCount = 4096;
-	std::array<u32, maxInstructionCount> loadedShader;    // Currently loaded & active shader
+	std::array<u32, maxInstructionCount> loadedShader;  // Currently loaded & active shader
 
 	PICAShader(ShaderType type) : type(type) {}
 
diff --git a/include/panda_qt/config_window.hpp b/include/panda_qt/config_window.hpp
index 795a6c8c..1e9648de 100644
--- a/include/panda_qt/config_window.hpp
+++ b/include/panda_qt/config_window.hpp
@@ -16,7 +16,6 @@
 
 #include "emulator.hpp"
 #include "frontend_settings.hpp"
-#include "input_mappings.hpp"
 #include "panda_qt/input_window.hpp"
 
 class ConfigWindow : public QDialog {
diff --git a/include/panda_qt/thread_debugger.hpp b/include/panda_qt/thread_debugger.hpp
index 76fe3509..eab9cffc 100644
--- a/include/panda_qt/thread_debugger.hpp
+++ b/include/panda_qt/thread_debugger.hpp
@@ -5,9 +5,6 @@
 #include <QTimer>
 #include <QVBoxLayout>
 #include <QtWidgets>
-#include <atomic>
-#include <chrono>
-#include <thread>
 
 #include "emulator.hpp"
 
diff --git a/include/sdl_sensors.hpp b/include/sdl_sensors.hpp
index 7e498afc..db982cec 100644
--- a/include/sdl_sensors.hpp
+++ b/include/sdl_sensors.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <cmath>
+#include <algorithm>
 #include <glm/glm.hpp>
 
 #include "helpers.hpp"
diff --git a/include/swap.hpp b/include/swap.hpp
index b7db9226..c0910f08 100644
--- a/include/swap.hpp
+++ b/include/swap.hpp
@@ -23,6 +23,7 @@
 #include <cstdlib>
 #endif
 #include <cstring>
+
 #include "helpers.hpp"
 
 // GCC
@@ -57,15 +58,9 @@
 namespace Common {
 
 #ifdef _MSC_VER
-[[nodiscard]] inline u16 swap16(u16 data) noexcept {
-    return _byteswap_ushort(data);
-}
-[[nodiscard]] inline u32 swap32(u32 data) noexcept {
-    return _byteswap_ulong(data);
-}
-[[nodiscard]] inline u64 swap64(u64 data) noexcept {
-    return _byteswap_uint64(data);
-}
+	[[nodiscard]] inline u16 swap16(u16 data) noexcept { return _byteswap_ushort(data); }
+	[[nodiscard]] inline u32 swap32(u32 data) noexcept { return _byteswap_ulong(data); }
+	[[nodiscard]] inline u64 swap64(u64 data) noexcept { return _byteswap_uint64(data); }
 #elif defined(__clang__) || defined(__GNUC__)
 #if defined(__Bitrig__) || defined(__OpenBSD__)
 // redefine swap16, swap32, swap64 as inline functions
@@ -73,523 +68,441 @@ namespace Common {
 #undef swap32
 #undef swap64
 #endif
-[[nodiscard]] inline u16 swap16(u16 data) noexcept {
-    return __builtin_bswap16(data);
-}
-[[nodiscard]] inline u32 swap32(u32 data) noexcept {
-    return __builtin_bswap32(data);
-}
-[[nodiscard]] inline u64 swap64(u64 data) noexcept {
-    return __builtin_bswap64(data);
-}
+	[[nodiscard]] inline u16 swap16(u16 data) noexcept { return __builtin_bswap16(data); }
+	[[nodiscard]] inline u32 swap32(u32 data) noexcept { return __builtin_bswap32(data); }
+	[[nodiscard]] inline u64 swap64(u64 data) noexcept { return __builtin_bswap64(data); }
 #else
-// Generic implementation.
-[[nodiscard]] inline u16 swap16(u16 data) noexcept {
-    return (data >> 8) | (data << 8);
-}
-[[nodiscard]] inline u32 swap32(u32 data) noexcept {
-    return ((data & 0xFF000000U) >> 24) | ((data & 0x00FF0000U) >> 8) |
-           ((data & 0x0000FF00U) << 8) | ((data & 0x000000FFU) << 24);
-}
-[[nodiscard]] inline u64 swap64(u64 data) noexcept {
-    return ((data & 0xFF00000000000000ULL) >> 56) | ((data & 0x00FF000000000000ULL) >> 40) |
-           ((data & 0x0000FF0000000000ULL) >> 24) | ((data & 0x000000FF00000000ULL) >> 8) |
-           ((data & 0x00000000FF000000ULL) << 8) | ((data & 0x0000000000FF0000ULL) << 24) |
-           ((data & 0x000000000000FF00ULL) << 40) | ((data & 0x00000000000000FFULL) << 56);
-}
+	// Generic implementation.
+	[[nodiscard]] inline u16 swap16(u16 data) noexcept { return (data >> 8) | (data << 8); }
+	[[nodiscard]] inline u32 swap32(u32 data) noexcept {
+		return ((data & 0xFF000000U) >> 24) | ((data & 0x00FF0000U) >> 8) | ((data & 0x0000FF00U) << 8) | ((data & 0x000000FFU) << 24);
+	}
+	[[nodiscard]] inline u64 swap64(u64 data) noexcept {
+		return ((data & 0xFF00000000000000ULL) >> 56) | ((data & 0x00FF000000000000ULL) >> 40) | ((data & 0x0000FF0000000000ULL) >> 24) |
+			   ((data & 0x000000FF00000000ULL) >> 8) | ((data & 0x00000000FF000000ULL) << 8) | ((data & 0x0000000000FF0000ULL) << 24) |
+			   ((data & 0x000000000000FF00ULL) << 40) | ((data & 0x00000000000000FFULL) << 56);
+	}
 #endif
 
-[[nodiscard]] inline float swapf(float f) noexcept {
-    static_assert(sizeof(u32) == sizeof(float), "float must be the same size as uint32_t.");
+	[[nodiscard]] inline float swapf(float f) noexcept {
+		static_assert(sizeof(u32) == sizeof(float), "float must be the same size as uint32_t.");
 
-    u32 value;
-    std::memcpy(&value, &f, sizeof(u32));
+		u32 value;
+		std::memcpy(&value, &f, sizeof(u32));
 
-    value = swap32(value);
-    std::memcpy(&f, &value, sizeof(u32));
+		value = swap32(value);
+		std::memcpy(&f, &value, sizeof(u32));
 
-    return f;
-}
+		return f;
+	}
 
-[[nodiscard]] inline double swapd(double f) noexcept {
-    static_assert(sizeof(u64) == sizeof(double), "double must be the same size as uint64_t.");
+	[[nodiscard]] inline double swapd(double f) noexcept {
+		static_assert(sizeof(u64) == sizeof(double), "double must be the same size as uint64_t.");
 
-    u64 value;
-    std::memcpy(&value, &f, sizeof(u64));
+		u64 value;
+		std::memcpy(&value, &f, sizeof(u64));
 
-    value = swap64(value);
-    std::memcpy(&f, &value, sizeof(u64));
+		value = swap64(value);
+		std::memcpy(&f, &value, sizeof(u64));
 
-    return f;
-}
+		return f;
+	}
 
-} // Namespace Common
+}  // Namespace Common
 
 template <typename T, typename F>
 struct swap_struct_t {
-    using swapped_t = swap_struct_t;
+	using swapped_t = swap_struct_t;
 
-protected:
-    T value;
+  protected:
+	T value;
 
-    static T swap(T v) {
-        return F::swap(v);
-    }
+	static T swap(T v) { return F::swap(v); }
 
-public:
-    T swap() const {
-        return swap(value);
-    }
-    swap_struct_t() = default;
-    swap_struct_t(const T& v) : value(swap(v)) {}
+  public:
+	T swap() const { return swap(value); }
+	swap_struct_t() = default;
+	swap_struct_t(const T& v) : value(swap(v)) {}
 
-    template <typename S>
-    swapped_t& operator=(const S& source) {
-        value = swap(static_cast<T>(source));
-        return *this;
-    }
+	template <typename S>
+	swapped_t& operator=(const S& source) {
+		value = swap(static_cast<T>(source));
+		return *this;
+	}
 
-    operator s8() const {
-        return static_cast<s8>(swap());
-    }
-    operator u8() const {
-        return static_cast<u8>(swap());
-    }
-    operator s16() const {
-        return static_cast<s16>(swap());
-    }
-    operator u16() const {
-        return static_cast<u16>(swap());
-    }
-    operator s32() const {
-        return static_cast<s32>(swap());
-    }
-    operator u32() const {
-        return static_cast<u32>(swap());
-    }
-    operator s64() const {
-        return static_cast<s64>(swap());
-    }
-    operator u64() const {
-        return static_cast<u64>(swap());
-    }
-    operator float() const {
-        return static_cast<float>(swap());
-    }
-    operator double() const {
-        return static_cast<double>(swap());
-    }
+	operator s8() const { return static_cast<s8>(swap()); }
+	operator u8() const { return static_cast<u8>(swap()); }
+	operator s16() const { return static_cast<s16>(swap()); }
+	operator u16() const { return static_cast<u16>(swap()); }
+	operator s32() const { return static_cast<s32>(swap()); }
+	operator u32() const { return static_cast<u32>(swap()); }
+	operator s64() const { return static_cast<s64>(swap()); }
+	operator u64() const { return static_cast<u64>(swap()); }
+	operator float() const { return static_cast<float>(swap()); }
+	operator double() const { return static_cast<double>(swap()); }
 
-    // +v
-    swapped_t operator+() const {
-        return +swap();
-    }
-    // -v
-    swapped_t operator-() const {
-        return -swap();
-    }
+	// +v
+	swapped_t operator+() const { return +swap(); }
+	// -v
+	swapped_t operator-() const { return -swap(); }
 
-    // v / 5
-    swapped_t operator/(const swapped_t& i) const {
-        return swap() / i.swap();
-    }
-    template <typename S>
-    swapped_t operator/(const S& i) const {
-        return swap() / i;
-    }
+	// v / 5
+	swapped_t operator/(const swapped_t& i) const { return swap() / i.swap(); }
+	template <typename S>
+	swapped_t operator/(const S& i) const {
+		return swap() / i;
+	}
 
-    // v * 5
-    swapped_t operator*(const swapped_t& i) const {
-        return swap() * i.swap();
-    }
-    template <typename S>
-    swapped_t operator*(const S& i) const {
-        return swap() * i;
-    }
+	// v * 5
+	swapped_t operator*(const swapped_t& i) const { return swap() * i.swap(); }
+	template <typename S>
+	swapped_t operator*(const S& i) const {
+		return swap() * i;
+	}
 
-    // v + 5
-    swapped_t operator+(const swapped_t& i) const {
-        return swap() + i.swap();
-    }
-    template <typename S>
-    swapped_t operator+(const S& i) const {
-        return swap() + static_cast<T>(i);
-    }
-    // v - 5
-    swapped_t operator-(const swapped_t& i) const {
-        return swap() - i.swap();
-    }
-    template <typename S>
-    swapped_t operator-(const S& i) const {
-        return swap() - static_cast<T>(i);
-    }
+	// v + 5
+	swapped_t operator+(const swapped_t& i) const { return swap() + i.swap(); }
+	template <typename S>
+	swapped_t operator+(const S& i) const {
+		return swap() + static_cast<T>(i);
+	}
+	// v - 5
+	swapped_t operator-(const swapped_t& i) const { return swap() - i.swap(); }
+	template <typename S>
+	swapped_t operator-(const S& i) const {
+		return swap() - static_cast<T>(i);
+	}
 
-    // v += 5
-    swapped_t& operator+=(const swapped_t& i) {
-        value = swap(swap() + i.swap());
-        return *this;
-    }
-    template <typename S>
-    swapped_t& operator+=(const S& i) {
-        value = swap(swap() + static_cast<T>(i));
-        return *this;
-    }
-    // v -= 5
-    swapped_t& operator-=(const swapped_t& i) {
-        value = swap(swap() - i.swap());
-        return *this;
-    }
-    template <typename S>
-    swapped_t& operator-=(const S& i) {
-        value = swap(swap() - static_cast<T>(i));
-        return *this;
-    }
+	// v += 5
+	swapped_t& operator+=(const swapped_t& i) {
+		value = swap(swap() + i.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator+=(const S& i) {
+		value = swap(swap() + static_cast<T>(i));
+		return *this;
+	}
+	// v -= 5
+	swapped_t& operator-=(const swapped_t& i) {
+		value = swap(swap() - i.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator-=(const S& i) {
+		value = swap(swap() - static_cast<T>(i));
+		return *this;
+	}
 
-    // ++v
-    swapped_t& operator++() {
-        value = swap(swap() + 1);
-        return *this;
-    }
-    // --v
-    swapped_t& operator--() {
-        value = swap(swap() - 1);
-        return *this;
-    }
+	// ++v
+	swapped_t& operator++() {
+		value = swap(swap() + 1);
+		return *this;
+	}
+	// --v
+	swapped_t& operator--() {
+		value = swap(swap() - 1);
+		return *this;
+	}
 
-    // v++
-    swapped_t operator++(int) {
-        swapped_t old = *this;
-        value = swap(swap() + 1);
-        return old;
-    }
-    // v--
-    swapped_t operator--(int) {
-        swapped_t old = *this;
-        value = swap(swap() - 1);
-        return old;
-    }
-    // Comparaison
-    // v == i
-    bool operator==(const swapped_t& i) const {
-        return swap() == i.swap();
-    }
-    template <typename S>
-    bool operator==(const S& i) const {
-        return swap() == i;
-    }
+	// v++
+	swapped_t operator++(int) {
+		swapped_t old = *this;
+		value = swap(swap() + 1);
+		return old;
+	}
+	// v--
+	swapped_t operator--(int) {
+		swapped_t old = *this;
+		value = swap(swap() - 1);
+		return old;
+	}
+	// Comparaison
+	// v == i
+	bool operator==(const swapped_t& i) const { return swap() == i.swap(); }
+	template <typename S>
+	bool operator==(const S& i) const {
+		return swap() == i;
+	}
 
-    // v != i
-    bool operator!=(const swapped_t& i) const {
-        return swap() != i.swap();
-    }
-    template <typename S>
-    bool operator!=(const S& i) const {
-        return swap() != i;
-    }
+	// v != i
+	bool operator!=(const swapped_t& i) const { return swap() != i.swap(); }
+	template <typename S>
+	bool operator!=(const S& i) const {
+		return swap() != i;
+	}
 
-    // v > i
-    bool operator>(const swapped_t& i) const {
-        return swap() > i.swap();
-    }
-    template <typename S>
-    bool operator>(const S& i) const {
-        return swap() > i;
-    }
+	// v > i
+	bool operator>(const swapped_t& i) const { return swap() > i.swap(); }
+	template <typename S>
+	bool operator>(const S& i) const {
+		return swap() > i;
+	}
 
-    // v < i
-    bool operator<(const swapped_t& i) const {
-        return swap() < i.swap();
-    }
-    template <typename S>
-    bool operator<(const S& i) const {
-        return swap() < i;
-    }
+	// v < i
+	bool operator<(const swapped_t& i) const { return swap() < i.swap(); }
+	template <typename S>
+	bool operator<(const S& i) const {
+		return swap() < i;
+	}
 
-    // v >= i
-    bool operator>=(const swapped_t& i) const {
-        return swap() >= i.swap();
-    }
-    template <typename S>
-    bool operator>=(const S& i) const {
-        return swap() >= i;
-    }
+	// v >= i
+	bool operator>=(const swapped_t& i) const { return swap() >= i.swap(); }
+	template <typename S>
+	bool operator>=(const S& i) const {
+		return swap() >= i;
+	}
 
-    // v <= i
-    bool operator<=(const swapped_t& i) const {
-        return swap() <= i.swap();
-    }
-    template <typename S>
-    bool operator<=(const S& i) const {
-        return swap() <= i;
-    }
+	// v <= i
+	bool operator<=(const swapped_t& i) const { return swap() <= i.swap(); }
+	template <typename S>
+	bool operator<=(const S& i) const {
+		return swap() <= i;
+	}
 
-    // logical
-    swapped_t operator!() const {
-        return !swap();
-    }
+	// logical
+	swapped_t operator!() const { return !swap(); }
 
-    // bitmath
-    swapped_t operator~() const {
-        return ~swap();
-    }
+	// bitmath
+	swapped_t operator~() const { return ~swap(); }
 
-    swapped_t operator&(const swapped_t& b) const {
-        return swap() & b.swap();
-    }
-    template <typename S>
-    swapped_t operator&(const S& b) const {
-        return swap() & b;
-    }
-    swapped_t& operator&=(const swapped_t& b) {
-        value = swap(swap() & b.swap());
-        return *this;
-    }
-    template <typename S>
-    swapped_t& operator&=(const S b) {
-        value = swap(swap() & b);
-        return *this;
-    }
+	swapped_t operator&(const swapped_t& b) const { return swap() & b.swap(); }
+	template <typename S>
+	swapped_t operator&(const S& b) const {
+		return swap() & b;
+	}
+	swapped_t& operator&=(const swapped_t& b) {
+		value = swap(swap() & b.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator&=(const S b) {
+		value = swap(swap() & b);
+		return *this;
+	}
 
-    swapped_t operator|(const swapped_t& b) const {
-        return swap() | b.swap();
-    }
-    template <typename S>
-    swapped_t operator|(const S& b) const {
-        return swap() | b;
-    }
-    swapped_t& operator|=(const swapped_t& b) {
-        value = swap(swap() | b.swap());
-        return *this;
-    }
-    template <typename S>
-    swapped_t& operator|=(const S& b) {
-        value = swap(swap() | b);
-        return *this;
-    }
+	swapped_t operator|(const swapped_t& b) const { return swap() | b.swap(); }
+	template <typename S>
+	swapped_t operator|(const S& b) const {
+		return swap() | b;
+	}
+	swapped_t& operator|=(const swapped_t& b) {
+		value = swap(swap() | b.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator|=(const S& b) {
+		value = swap(swap() | b);
+		return *this;
+	}
 
-    swapped_t operator^(const swapped_t& b) const {
-        return swap() ^ b.swap();
-    }
-    template <typename S>
-    swapped_t operator^(const S& b) const {
-        return swap() ^ b;
-    }
-    swapped_t& operator^=(const swapped_t& b) {
-        value = swap(swap() ^ b.swap());
-        return *this;
-    }
-    template <typename S>
-    swapped_t& operator^=(const S& b) {
-        value = swap(swap() ^ b);
-        return *this;
-    }
+	swapped_t operator^(const swapped_t& b) const { return swap() ^ b.swap(); }
+	template <typename S>
+	swapped_t operator^(const S& b) const {
+		return swap() ^ b;
+	}
+	swapped_t& operator^=(const swapped_t& b) {
+		value = swap(swap() ^ b.swap());
+		return *this;
+	}
+	template <typename S>
+	swapped_t& operator^=(const S& b) {
+		value = swap(swap() ^ b);
+		return *this;
+	}
 
-    template <typename S>
-    swapped_t operator<<(const S& b) const {
-        return swap() << b;
-    }
-    template <typename S>
-    swapped_t& operator<<=(const S& b) const {
-        value = swap(swap() << b);
-        return *this;
-    }
+	template <typename S>
+	swapped_t operator<<(const S& b) const {
+		return swap() << b;
+	}
+	template <typename S>
+	swapped_t& operator<<=(const S& b) const {
+		value = swap(swap() << b);
+		return *this;
+	}
 
-    template <typename S>
-    swapped_t operator>>(const S& b) const {
-        return swap() >> b;
-    }
-    template <typename S>
-    swapped_t& operator>>=(const S& b) const {
-        value = swap(swap() >> b);
-        return *this;
-    }
+	template <typename S>
+	swapped_t operator>>(const S& b) const {
+		return swap() >> b;
+	}
+	template <typename S>
+	swapped_t& operator>>=(const S& b) const {
+		value = swap(swap() >> b);
+		return *this;
+	}
 
-    // Member
-    /** todo **/
+	// Member
+	/** todo **/
 
-    // Arithmetics
-    template <typename S, typename T2, typename F2>
-    friend S operator+(const S& p, const swapped_t v);
+	// Arithmetics
+	template <typename S, typename T2, typename F2>
+	friend S operator+(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend S operator-(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend S operator-(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend S operator/(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend S operator/(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend S operator*(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend S operator*(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend S operator%(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend S operator%(const S& p, const swapped_t v);
 
-    // Arithmetics + assignments
-    template <typename S, typename T2, typename F2>
-    friend S operator+=(const S& p, const swapped_t v);
+	// Arithmetics + assignments
+	template <typename S, typename T2, typename F2>
+	friend S operator+=(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend S operator-=(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend S operator-=(const S& p, const swapped_t v);
 
-    // Bitmath
-    template <typename S, typename T2, typename F2>
-    friend S operator&(const S& p, const swapped_t v);
+	// Bitmath
+	template <typename S, typename T2, typename F2>
+	friend S operator&(const S& p, const swapped_t v);
 
-    // Comparison
-    template <typename S, typename T2, typename F2>
-    friend bool operator<(const S& p, const swapped_t v);
+	// Comparison
+	template <typename S, typename T2, typename F2>
+	friend bool operator<(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend bool operator>(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend bool operator>(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend bool operator<=(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend bool operator<=(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend bool operator>=(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend bool operator>=(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend bool operator!=(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend bool operator!=(const S& p, const swapped_t v);
 
-    template <typename S, typename T2, typename F2>
-    friend bool operator==(const S& p, const swapped_t v);
+	template <typename S, typename T2, typename F2>
+	friend bool operator==(const S& p, const swapped_t v);
 };
 
 // Arithmetics
 template <typename S, typename T, typename F>
 S operator+(const S& i, const swap_struct_t<T, F> v) {
-    return i + v.swap();
+	return i + v.swap();
 }
 
 template <typename S, typename T, typename F>
 S operator-(const S& i, const swap_struct_t<T, F> v) {
-    return i - v.swap();
+	return i - v.swap();
 }
 
 template <typename S, typename T, typename F>
 S operator/(const S& i, const swap_struct_t<T, F> v) {
-    return i / v.swap();
+	return i / v.swap();
 }
 
 template <typename S, typename T, typename F>
 S operator*(const S& i, const swap_struct_t<T, F> v) {
-    return i * v.swap();
+	return i * v.swap();
 }
 
 template <typename S, typename T, typename F>
 S operator%(const S& i, const swap_struct_t<T, F> v) {
-    return i % v.swap();
+	return i % v.swap();
 }
 
 // Arithmetics + assignments
 template <typename S, typename T, typename F>
 S& operator+=(S& i, const swap_struct_t<T, F> v) {
-    i += v.swap();
-    return i;
+	i += v.swap();
+	return i;
 }
 
 template <typename S, typename T, typename F>
 S& operator-=(S& i, const swap_struct_t<T, F> v) {
-    i -= v.swap();
-    return i;
+	i -= v.swap();
+	return i;
 }
 
 // Logical
 template <typename S, typename T, typename F>
 S operator&(const S& i, const swap_struct_t<T, F> v) {
-    return i & v.swap();
+	return i & v.swap();
 }
 
 template <typename S, typename T, typename F>
 S operator&(const swap_struct_t<T, F> v, const S& i) {
-    return static_cast<S>(v.swap() & i);
+	return static_cast<S>(v.swap() & i);
 }
 
 // Comparaison
 template <typename S, typename T, typename F>
 bool operator<(const S& p, const swap_struct_t<T, F> v) {
-    return p < v.swap();
+	return p < v.swap();
 }
 template <typename S, typename T, typename F>
 bool operator>(const S& p, const swap_struct_t<T, F> v) {
-    return p > v.swap();
+	return p > v.swap();
 }
 template <typename S, typename T, typename F>
 bool operator<=(const S& p, const swap_struct_t<T, F> v) {
-    return p <= v.swap();
+	return p <= v.swap();
 }
 template <typename S, typename T, typename F>
 bool operator>=(const S& p, const swap_struct_t<T, F> v) {
-    return p >= v.swap();
+	return p >= v.swap();
 }
 template <typename S, typename T, typename F>
 bool operator!=(const S& p, const swap_struct_t<T, F> v) {
-    return p != v.swap();
+	return p != v.swap();
 }
 template <typename S, typename T, typename F>
 bool operator==(const S& p, const swap_struct_t<T, F> v) {
-    return p == v.swap();
+	return p == v.swap();
 }
 
 template <typename T>
 struct swap_64_t {
-    static T swap(T x) {
-        return static_cast<T>(Common::swap64(x));
-    }
+	static T swap(T x) { return static_cast<T>(Common::swap64(x)); }
 };
 
 template <typename T>
 struct swap_32_t {
-    static T swap(T x) {
-        return static_cast<T>(Common::swap32(x));
-    }
+	static T swap(T x) { return static_cast<T>(Common::swap32(x)); }
 };
 
 template <typename T>
 struct swap_16_t {
-    static T swap(T x) {
-        return static_cast<T>(Common::swap16(x));
-    }
+	static T swap(T x) { return static_cast<T>(Common::swap16(x)); }
 };
 
 template <typename T>
 struct swap_float_t {
-    static T swap(T x) {
-        return static_cast<T>(Common::swapf(x));
-    }
+	static T swap(T x) { return static_cast<T>(Common::swapf(x)); }
 };
 
 template <typename T>
 struct swap_double_t {
-    static T swap(T x) {
-        return static_cast<T>(Common::swapd(x));
-    }
+	static T swap(T x) { return static_cast<T>(Common::swapd(x)); }
 };
 
 template <typename T>
 struct swap_enum_t {
-    static_assert(std::is_enum_v<T>);
-    using base = std::underlying_type_t<T>;
+	static_assert(std::is_enum_v<T>);
+	using base = std::underlying_type_t<T>;
 
-public:
-    swap_enum_t() = default;
-    swap_enum_t(const T& v) : value(swap(v)) {}
+  public:
+	swap_enum_t() = default;
+	swap_enum_t(const T& v) : value(swap(v)) {}
 
-    swap_enum_t& operator=(const T& v) {
-        value = swap(v);
-        return *this;
-    }
+	swap_enum_t& operator=(const T& v) {
+		value = swap(v);
+		return *this;
+	}
 
-    operator T() const {
-        return swap(value);
-    }
+	operator T() const { return swap(value); }
 
-    explicit operator base() const {
-        return static_cast<base>(swap(value));
-    }
+	explicit operator base() const { return static_cast<base>(swap(value)); }
 
-protected:
-    T value{};
-    // clang-format off
+  protected:
+	T value{};
+	// clang-format off
     using swap_t = std::conditional_t<
         std::is_same_v<base, u16>, swap_16_t<u16>, std::conditional_t<
         std::is_same_v<base, s16>, swap_16_t<s16>, std::conditional_t<
@@ -597,14 +510,12 @@ protected:
         std::is_same_v<base, s32>, swap_32_t<s32>, std::conditional_t<
         std::is_same_v<base, u64>, swap_64_t<u64>, std::conditional_t<
         std::is_same_v<base, s64>, swap_64_t<s64>, void>>>>>>;
-    // clang-format on
-    static T swap(T x) {
-        return static_cast<T>(swap_t::swap(static_cast<base>(x)));
-    }
+	// clang-format on
+	static T swap(T x) { return static_cast<T>(swap_t::swap(static_cast<base>(x))); }
 };
 
-struct SwapTag {}; // Use the different endianness from the system
-struct KeepTag {}; // Use the same endianness as the system
+struct SwapTag {};  // Use the different endianness from the system
+struct KeepTag {};  // Use the same endianness as the system
 
 template <typename T, typename Tag>
 struct AddEndian;
@@ -613,65 +524,65 @@ struct AddEndian;
 
 template <typename T>
 struct AddEndian<T, KeepTag> {
-    using type = T;
+	using type = T;
 };
 
 // SwapTag specializations
 
 template <>
 struct AddEndian<u8, SwapTag> {
-    using type = u8;
+	using type = u8;
 };
 
 template <>
 struct AddEndian<u16, SwapTag> {
-    using type = swap_struct_t<u16, swap_16_t<u16>>;
+	using type = swap_struct_t<u16, swap_16_t<u16>>;
 };
 
 template <>
 struct AddEndian<u32, SwapTag> {
-    using type = swap_struct_t<u32, swap_32_t<u32>>;
+	using type = swap_struct_t<u32, swap_32_t<u32>>;
 };
 
 template <>
 struct AddEndian<u64, SwapTag> {
-    using type = swap_struct_t<u64, swap_64_t<u64>>;
+	using type = swap_struct_t<u64, swap_64_t<u64>>;
 };
 
 template <>
 struct AddEndian<s8, SwapTag> {
-    using type = s8;
+	using type = s8;
 };
 
 template <>
 struct AddEndian<s16, SwapTag> {
-    using type = swap_struct_t<s16, swap_16_t<s16>>;
+	using type = swap_struct_t<s16, swap_16_t<s16>>;
 };
 
 template <>
 struct AddEndian<s32, SwapTag> {
-    using type = swap_struct_t<s32, swap_32_t<s32>>;
+	using type = swap_struct_t<s32, swap_32_t<s32>>;
 };
 
 template <>
 struct AddEndian<s64, SwapTag> {
-    using type = swap_struct_t<s64, swap_64_t<s64>>;
+	using type = swap_struct_t<s64, swap_64_t<s64>>;
 };
 
 template <>
 struct AddEndian<float, SwapTag> {
-    using type = swap_struct_t<float, swap_float_t<float>>;
+	using type = swap_struct_t<float, swap_float_t<float>>;
 };
 
 template <>
 struct AddEndian<double, SwapTag> {
-    using type = swap_struct_t<double, swap_double_t<double>>;
+	using type = swap_struct_t<double, swap_double_t<double>>;
 };
 
 template <typename T>
 struct AddEndian<T, SwapTag> {
-    static_assert(std::is_enum_v<T>);
-    using type = swap_enum_t<T>;
+	static_assert(std::is_enum_v<T>);
+	using type = swap_enum_t<T>;
 };
 
 // Alias LETag/BETag as KeepTag/SwapTag depending on the system