From 4c8bb9356008c5255c47c576aeffb361cf91e33e Mon Sep 17 00:00:00 2001
From: Alexander Shabalin <alexander.shabalin@jetbrains.com>
Date: Thu, 27 Jan 2022 12:32:40 +0000
Subject: [PATCH] [K/N] Helpers for saturating arithmetics in runtime

Merge-request: KT-MR-5496
Merged-by: Alexander Shabalin <Alexander.Shabalin@jetbrains.com>
---
 .../runtime/src/main/cpp/Saturating.hpp       |  312 ++
 .../runtime/src/main/cpp/SaturatingTest.cpp   | 4767 +++++++++++++++++
 2 files changed, 5079 insertions(+)
 create mode 100644 kotlin-native/runtime/src/main/cpp/Saturating.hpp
 create mode 100644 kotlin-native/runtime/src/main/cpp/SaturatingTest.cpp

diff --git a/kotlin-native/runtime/src/main/cpp/Saturating.hpp b/kotlin-native/runtime/src/main/cpp/Saturating.hpp
new file mode 100644
index 00000000000..21ca27e30f9
--- /dev/null
+++ b/kotlin-native/runtime/src/main/cpp/Saturating.hpp
@@ -0,0 +1,312 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+#include <cstdint>
+#include <functional>
+#include <limits>
+
+namespace kotlin {
+
+namespace internal {
+
+// Not using std::common_type, because it allows to convert between unsigned and signed with losing information, and
+// is otherwise not intuitive. Examples:
+// * std::common_type_t<int8_t, uint32_t> is uint32_t - negative numbers are lost.
+// * std::common_type_t<int8_t, int16_t> is int32_t - int16_t is enough, surely.
+// * std::common_type_t<uint8_t, uint16_t> is int32_t - why did it become signed?
+template <typename T, typename U>
+struct wider {
+    static_assert(std::is_integral_v<T>, "T must be integral");
+    static_assert(std::is_integral_v<U>, "U must be integral");
+    static_assert(std::is_signed_v<T> == std::is_signed_v<U>, "T and U must have the same sign");
+
+    using type = std::conditional_t<sizeof(T) >= sizeof(U), T, U>;
+};
+
+template <typename T, typename U>
+using wider_t = typename wider<T, U>::type;
+
+} // namespace internal
+
+template <typename U, typename T>
+constexpr U saturating_cast(T value) noexcept {
+    static_assert(std::is_integral_v<T>, "T must be integral");
+    static_assert(std::is_integral_v<U>, "U must be integral");
+
+    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>) {
+        if constexpr (sizeof(U) >= sizeof(T)) {
+            // When T and U are of the same sign, and U can accomodate T, it's safe to convert it.
+            return value;
+        }
+        if (value > static_cast<T>(std::numeric_limits<U>::max())) {
+            // T is a bigger type and holds a bigger value than U can hold.
+            return std::numeric_limits<U>::max();
+        }
+        if (value < static_cast<T>(std::numeric_limits<U>::min())) {
+            // T is a bigger type and holds a smaller value than U can hold.
+            return std::numeric_limits<U>::min();
+        }
+        // T is a bigger type, but its value fits in U.
+        return static_cast<U>(value);
+    } else if constexpr (std::is_signed_v<U>) {
+        static_assert(!std::is_signed_v<T>);
+
+        if constexpr (sizeof(U) > sizeof(T)) {
+            // U is signed but strictly bigger than T, it's safe to convert.
+            return static_cast<U>(value);
+        }
+
+        if (value > static_cast<T>(std::numeric_limits<U>::max())) {
+            // T is a bigger type or is the same size but unsigned vs signed, and holds a bigger value than U can hold.
+            return std::numeric_limits<U>::max();
+        }
+        // T is unsigned, and U is signed, so T's min cannot be less than U's min.
+        // T is bigger, but its value fits in U.
+        return static_cast<U>(value);
+    } else {
+        static_assert(std::is_signed_v<T>);
+        static_assert(!std::is_signed_v<U>);
+
+        if (value < 0) {
+            // U is unsigned, its min is 0.
+            return 0;
+        }
+        if constexpr (sizeof(U) >= sizeof(T)) {
+            // T is signed, U - unsigned, and U is not less than T. So, max of T is less than max of U.
+            return static_cast<U>(value);
+        }
+        if (value > static_cast<T>(std::numeric_limits<U>::max())) {
+            // T is a bigger type and holds a bigger value than U can hold.
+            return std::numeric_limits<U>::max();
+        }
+        // T is a bigger type but its value fits in U.
+        return static_cast<U>(value);
+    }
+}
+
+template <typename T, typename U>
+constexpr auto saturating_add(T lhs, U rhs) noexcept {
+    static_assert(std::is_integral_v<T>, "T must be integral");
+    static_assert(std::is_integral_v<U>, "U must be integral");
+    static_assert(std::is_signed_v<T> == std::is_signed_v<U>, "T and U must have the same sign");
+
+    using Result = internal::wider_t<T, U>;
+    Result result;
+    if (__builtin_add_overflow(lhs, rhs, &result)) {
+        if (rhs >= 0) {
+            // Adding a non-negative number caused an overflow => overflowed upwards.
+            result = std::numeric_limits<Result>::max();
+        } else {
+            // Adding a negative number caused an overflow => overflowed downwards.
+            result = std::numeric_limits<Result>::min();
+        }
+    }
+    return result;
+}
+
+template <typename T, typename U>
+constexpr auto saturating_sub(T lhs, U rhs) noexcept {
+    static_assert(std::is_integral_v<T>, "T must be integral");
+    static_assert(std::is_integral_v<U>, "U must be integral");
+    static_assert(std::is_signed_v<T> == std::is_signed_v<U>, "T and U must have the same sign");
+
+    using Result = internal::wider_t<T, U>;
+    Result result;
+    if (__builtin_sub_overflow(lhs, rhs, &result)) {
+        if (rhs >= 0) {
+            // Subtracting a non-negative number caused an overflow => overflowed downwards.
+            result = std::numeric_limits<Result>::min();
+        } else {
+            // Subtracting a negative number caused an overflow => overflowed upwards.
+            result = std::numeric_limits<Result>::max();
+        }
+    }
+    return result;
+}
+
+template <typename T, typename U>
+constexpr auto saturating_mul(T lhs, U rhs) noexcept {
+    static_assert(std::is_integral_v<T>, "T must be integral");
+    static_assert(std::is_integral_v<U>, "U must be integral");
+    static_assert(std::is_signed_v<T> == std::is_signed_v<U>, "T and U must have the same sign");
+
+    using Result = internal::wider_t<T, U>;
+    Result result;
+    if (__builtin_mul_overflow(lhs, rhs, &result)) {
+        if (lhs >= 0 && rhs >= 0) {
+            // Multiplying non-negative numbers caused an overflow => overflowed upwards.
+            result = std::numeric_limits<Result>::max();
+        } else if (lhs < 0 && rhs < 0) {
+            // Multiplying negative numbers caused an overflow => overflowed upwards.
+            result = std::numeric_limits<Result>::max();
+        } else {
+            // Multiplying non-negative number by a negative number caused an overflow => overflowed downwards.
+            result = std::numeric_limits<Result>::min();
+        }
+    }
+    return result;
+}
+
+template <typename T>
+struct saturating {
+    static_assert(std::is_integral_v<T>, "saturating is only defined for integers.");
+
+    using value_type = T;
+
+    // The underlying value.
+    T value;
+
+    // Construct from any value using saturating_cast.
+    template <typename U>
+    explicit constexpr saturating(U value) noexcept : value(saturating_cast<T>(value)) {}
+
+    // Construct from any other saturating type using saturating_cast.
+    template <typename U>
+    explicit constexpr saturating(saturating<U> other) noexcept : value(saturating_cast<T>(other.value)) {}
+
+    ~saturating() = default;
+    constexpr saturating(const saturating&) noexcept = default;
+    constexpr saturating& operator=(const saturating&) noexcept = default;
+
+    // Explicitly convert into any value using saturating_cast.
+    template <typename U>
+    explicit constexpr operator U() const noexcept {
+        return saturating_cast<U>(value);
+    }
+
+    constexpr bool operator==(saturating other) const noexcept { return value == other.value; }
+
+    constexpr bool operator!=(saturating other) const noexcept { return value != other.value; }
+
+    constexpr bool operator<(saturating other) const noexcept { return value < other.value; }
+
+    constexpr bool operator<=(saturating other) const noexcept { return value <= other.value; }
+
+    constexpr bool operator>(saturating other) const noexcept { return value > other.value; }
+
+    constexpr bool operator>=(saturating other) const noexcept { return value >= other.value; }
+};
+
+template <typename T>
+saturating(T) -> saturating<T>;
+
+// Saturated addition.
+template <typename T, typename U>
+constexpr auto operator+(saturating<T> lhs, saturating<U> rhs) noexcept {
+    return saturating(saturating_add(lhs.value, rhs.value));
+}
+
+// Saturated addition.
+template <typename T, typename U>
+constexpr saturating<T>& operator+=(saturating<T>& lhs, saturating<U> rhs) noexcept {
+    auto result = lhs + rhs;
+    lhs = saturating<T>(result);
+    return lhs;
+}
+
+// Saturated subtraction.
+template <typename T, typename U>
+constexpr auto operator-(saturating<T> lhs, saturating<U> rhs) noexcept {
+    return saturating(saturating_sub(lhs.value, rhs.value));
+}
+
+// Saturated subtraction.
+template <typename T, typename U>
+constexpr saturating<T>& operator-=(saturating<T>& lhs, saturating<U> rhs) noexcept {
+    auto result = lhs - rhs;
+    lhs = saturating<T>(result);
+    return lhs;
+}
+
+// Saturated multiplication.
+template <typename T, typename U>
+constexpr auto operator*(saturating<T> lhs, saturating<U> rhs) noexcept {
+    return saturating(saturating_mul(lhs.value, rhs.value));
+}
+
+// Saturated multiplication.
+template <typename T, typename U>
+constexpr saturating<T>& operator*=(saturating<T>& lhs, saturating<U> rhs) noexcept {
+    auto result = lhs * rhs;
+    lhs = saturating<T>(result);
+    return lhs;
+}
+
+// TODO: Saturated division and modulo. (there are no builtins for that)
+// TODO: Saturated negation: for signed types -MIN overflows MAX; but what to do for unsigned types?
+
+using int_sat8_t = saturating<int8_t>;
+using int_sat16_t = saturating<int16_t>;
+using int_sat32_t = saturating<int32_t>;
+using int_sat64_t = saturating<int64_t>;
+using uint_sat8_t = saturating<uint8_t>;
+using uint_sat16_t = saturating<uint16_t>;
+using uint_sat32_t = saturating<uint32_t>;
+using uint_sat64_t = saturating<uint64_t>;
+using size_sat_t = saturating<size_t>;
+
+} // namespace kotlin
+
+namespace std {
+
+template <typename T, typename U>
+struct common_type<kotlin::saturating<T>, kotlin::saturating<U>> {
+    static_assert(std::is_signed_v<T> == std::is_signed_v<U>, "Requires T and U be of same signedness");
+
+    using type = kotlin::saturating<kotlin::internal::wider_t<T, U>>;
+};
+
+template <typename T, typename U>
+struct common_type<kotlin::saturating<T>, U> {
+    static_assert(std::is_integral_v<U>, "Requires U to be integral");
+    static_assert(std::is_signed_v<T> == std::is_signed_v<U>, "Requires T and U be of same signedness");
+
+    using type = kotlin::saturating<kotlin::internal::wider_t<T, U>>;
+};
+
+template <typename T>
+struct hash<kotlin::saturating<T>> {
+    size_t operator()(const kotlin::saturating<T>& value) const { return hash<T>(value.value); }
+};
+
+template <typename T>
+class numeric_limits<kotlin::saturating<T>> {
+public:
+    static constexpr bool is_specialized = true;
+    static constexpr bool is_signed = numeric_limits<T>::is_signed;
+    static constexpr bool is_integer = numeric_limits<T>::is_integer;
+    static constexpr bool is_exact = numeric_limits<T>::is_exact;
+    static constexpr bool has_infinity = numeric_limits<T>::has_infinity;
+    static constexpr bool has_quiet_NaN = numeric_limits<T>::has_quiet_NaN;
+    static constexpr bool has_signaling_NaN = numeric_limits<T>::has_signaling_NaN;
+    static constexpr std::float_denorm_style has_denorm = numeric_limits<T>::has_denorm;
+    static constexpr bool has_denorm_loss = numeric_limits<T>::has_denorm_loss;
+    static constexpr std::float_round_style round_style = numeric_limits<T>::round_style;
+    static constexpr bool is_iec559 = numeric_limits<T>::is_iec559;
+    static constexpr bool is_bounded = numeric_limits<T>::is_bounded;
+    static constexpr bool is_modulo = false; // Because it's saturating.
+    static constexpr int digits = numeric_limits<T>::digits;
+    static constexpr int digits10 = numeric_limits<T>::digits10;
+    static constexpr int max_digits10 = numeric_limits<T>::max_digits10;
+    static constexpr int radix = numeric_limits<T>::radix;
+    static constexpr int min_exponent = numeric_limits<T>::min_exponent;
+    static constexpr int min_exponent10 = numeric_limits<T>::min_exponent10;
+    static constexpr int max_exponent = numeric_limits<T>::max_exponent;
+    static constexpr int max_exponent10 = numeric_limits<T>::max_exponent10;
+    static constexpr bool traps = numeric_limits<T>::traps;
+    static constexpr bool tinyness_before = numeric_limits<T>::tinyness_before;
+
+    static constexpr kotlin::saturating<T> min() noexcept { return kotlin::saturating(std::numeric_limits<T>::min()); }
+    static constexpr kotlin::saturating<T> lowest() noexcept { return kotlin::saturating(std::numeric_limits<T>::lowest()); }
+    static constexpr kotlin::saturating<T> max() noexcept { return kotlin::saturating(std::numeric_limits<T>::max()); }
+    static constexpr kotlin::saturating<T> epsilon() noexcept { return kotlin::saturating(std::numeric_limits<T>::epsilon()); }
+    static constexpr kotlin::saturating<T> round_error() noexcept { return kotlin::saturating(std::numeric_limits<T>::round_error()); }
+    static constexpr kotlin::saturating<T> infinity() noexcept { return kotlin::saturating(std::numeric_limits<T>::infinity()); }
+    static constexpr kotlin::saturating<T> quiet_NaN() noexcept { return kotlin::saturating(std::numeric_limits<T>::quiet_NaN()); }
+    static constexpr kotlin::saturating<T> signaling_NaN() noexcept { return kotlin::saturating(std::numeric_limits<T>::signaling_NaN()); }
+    static constexpr kotlin::saturating<T> denorm_min() noexcept { return kotlin::saturating(std::numeric_limits<T>::denorm_min()); }
+};
+
+} // namespace std
diff --git a/kotlin-native/runtime/src/main/cpp/SaturatingTest.cpp b/kotlin-native/runtime/src/main/cpp/SaturatingTest.cpp
new file mode 100644
index 00000000000..51e719c4673
--- /dev/null
+++ b/kotlin-native/runtime/src/main/cpp/SaturatingTest.cpp
@@ -0,0 +1,4767 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+#include "Saturating.hpp"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using namespace kotlin;
+
+// What follows are some sanity tests on saturating usage, then an extensive test of allowed conversions
+// and resulting types of sanity<T> operations, then an extensive test of saturating_* operations using
+// values MIN, MIN + 1, -1, 0, 1, MAX - 1, MAX.
+
+TEST(SaturatingSanityTest, SaturatingCast) {
+    EXPECT_THAT(saturating_cast<int8_t>(129), 127);
+    EXPECT_THAT(saturating_cast<int8_t>(-129), -128);
+    EXPECT_THAT(saturating_cast<uint32_t>(-17), 0);
+}
+
+TEST(SaturatingSanityTest, SaturatingAdd) {
+    EXPECT_THAT(saturating_add(4, 1), 5);
+    EXPECT_THAT(saturating_add(1, -2), -1);
+    EXPECT_THAT(saturating_add(uint8_t(127), uint16_t(5)), 132);
+    EXPECT_THAT(saturating_add(int8_t(-127), int16_t(-5)), -132);
+}
+
+TEST(SaturatingSanityTest, SaturatingSub) {
+    EXPECT_THAT(saturating_sub(4, 1), 3);
+    EXPECT_THAT(saturating_sub(1, -2), 3);
+    EXPECT_THAT(saturating_sub(uint16_t(5), uint8_t(127)), 0);
+    EXPECT_THAT(saturating_sub(uint16_t(129), uint8_t(127)), 2);
+    EXPECT_THAT(saturating_sub(int8_t(-127), int16_t(5)), -132);
+}
+
+TEST(SaturatingSanityTest, SaturatingMul) {
+    EXPECT_THAT(saturating_mul(3, 5), 15);
+    EXPECT_THAT(saturating_mul(-3, 5), -15);
+    EXPECT_THAT(saturating_mul(uint8_t(127), uint16_t(2)), 254);
+    EXPECT_THAT(saturating_mul(uint8_t(127), uint16_t(1000)), 65535);
+    EXPECT_THAT(saturating_mul(int8_t(-127), int16_t(2)), -254);
+    EXPECT_THAT(saturating_mul(int8_t(-127), int16_t(1000)), -32768);
+    EXPECT_THAT(saturating_mul(int8_t(-127), int16_t(-2)), 254);
+    EXPECT_THAT(saturating_mul(int8_t(-127), int16_t(-1000)), 32767);
+}
+
+TEST(SaturatingSanityTest, SaturatingComparison) {
+    EXPECT_TRUE(saturating(1) == saturating(1));
+    EXPECT_FALSE(saturating(1) == saturating(2));
+    EXPECT_FALSE(saturating(2) == saturating(1));
+
+    EXPECT_FALSE(saturating(1) != saturating(1));
+    EXPECT_TRUE(saturating(1) != saturating(2));
+    EXPECT_TRUE(saturating(2) != saturating(1));
+
+    EXPECT_FALSE(saturating(1) < saturating(1));
+    EXPECT_TRUE(saturating(1) < saturating(2));
+    EXPECT_FALSE(saturating(2) < saturating(1));
+
+    EXPECT_TRUE(saturating(1) <= saturating(1));
+    EXPECT_TRUE(saturating(1) <= saturating(2));
+    EXPECT_FALSE(saturating(2) <= saturating(1));
+
+    EXPECT_FALSE(saturating(1) > saturating(1));
+    EXPECT_FALSE(saturating(1) > saturating(2));
+    EXPECT_TRUE(saturating(2) > saturating(1));
+
+    EXPECT_TRUE(saturating(1) >= saturating(1));
+    EXPECT_FALSE(saturating(1) >= saturating(2));
+    EXPECT_TRUE(saturating(2) >= saturating(1));
+}
+
+TEST(SaturatingSanityTest, SaturatingOutOfPlace) {
+    EXPECT_THAT(saturating(int8_t(2)) + saturating(int8_t(3)), saturating(int8_t(5)));
+    EXPECT_THAT(saturating(int8_t(2)) + saturating(int16_t(3)), saturating(int16_t(5)));
+    EXPECT_THAT(saturating(int8_t(2)) + saturating(int16_t(1000)), saturating(int16_t(1002)));
+    EXPECT_THAT(saturating(int8_t(2)) + saturating(int16_t(32767)), saturating(int16_t(32767)));
+
+    EXPECT_THAT(saturating(int8_t(2)) - saturating(int8_t(3)), saturating(int8_t(-1)));
+    EXPECT_THAT(saturating(int8_t(2)) - saturating(int16_t(3)), saturating(int16_t(-1)));
+    EXPECT_THAT(saturating(int8_t(2)) - saturating(int16_t(1000)), saturating(int16_t(-998)));
+    EXPECT_THAT(saturating(int8_t(2)) - saturating(int16_t(-32768)), saturating(int16_t(32767)));
+
+    EXPECT_THAT(saturating(int8_t(2)) * saturating(int8_t(3)), saturating(int8_t(6)));
+    EXPECT_THAT(saturating(int8_t(2)) * saturating(int16_t(3)), saturating(int16_t(6)));
+    EXPECT_THAT(saturating(int8_t(2)) * saturating(int16_t(1000)), saturating(int16_t(2000)));
+    EXPECT_THAT(saturating(int8_t(2)) * saturating(int16_t(20000)), saturating(int16_t(32767)));
+}
+
+TEST(SaturatingSanityTest, SaturatingInPlace) {
+    saturating value(int8_t(13));
+    EXPECT_THAT(int8_t(value), 13);
+    value += saturating(int8_t(15));
+    EXPECT_THAT(int8_t(value), 28);
+    value += saturating(int16_t(1000));
+    EXPECT_THAT(int8_t(value), 127);
+    value -= saturating(int16_t(200));
+    EXPECT_THAT(int8_t(value), -73);
+    value -= saturating(int8_t(100));
+    EXPECT_THAT(int8_t(value), -128);
+    value *= saturating(0);
+    EXPECT_THAT(int8_t(value), 0);
+    value += saturating(2);
+    EXPECT_THAT(int8_t(value), 2);
+    value *= saturating(int8_t(10));
+    EXPECT_THAT(int8_t(value), 20);
+    value *= saturating(int16_t(1000));
+    EXPECT_THAT(int8_t(value), 127);
+    value *= saturating(int8_t(-1));
+    EXPECT_THAT(int8_t(value), -127);
+    value *= saturating(int16_t(1000));
+    EXPECT_THAT(int8_t(value), -128);
+}
+
+namespace {
+
+template <typename From, typename Into>
+inline constexpr bool is_explicitly_convertible_v = !std::is_convertible_v<From, Into> && std::is_constructible_v<Into, From>;
+
+} // namespace
+
+TEST(SaturatingTest, ValueConstructor) {
+    static_assert(is_explicitly_convertible_v<int8_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int8_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int8_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int8_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<int8_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int8_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int8_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int8_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<int16_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int16_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int16_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int16_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<int16_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int16_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int16_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int16_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<int32_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int32_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int32_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int32_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<int32_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int32_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int32_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int32_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<int64_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int64_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int64_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int64_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<int64_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int64_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int64_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int64_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint8_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint8_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint8_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint8_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<uint8_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint8_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint8_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint8_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint16_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint16_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint16_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint16_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<uint16_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint16_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint16_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint16_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint32_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint32_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint32_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint32_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<uint32_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint32_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint32_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint32_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint64_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint64_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint64_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint64_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<uint64_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint64_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint64_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint64_t, uint_sat64_t>);
+}
+
+TEST(SaturatingTest, ValueCast) {
+    static_assert(is_explicitly_convertible_v<int_sat8_t, int8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, int16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, int32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, int64_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, uint8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, uint16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, uint32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, uint64_t>);
+
+    static_assert(is_explicitly_convertible_v<int_sat16_t, int8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, int16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, int32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, int64_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, uint8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, uint16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, uint32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, uint64_t>);
+
+    static_assert(is_explicitly_convertible_v<int_sat32_t, int8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, int16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, int32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, int64_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, uint8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, uint16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, uint32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, uint64_t>);
+
+    static_assert(is_explicitly_convertible_v<int_sat64_t, int8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, int16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, int32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, int64_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, uint8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, uint16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, uint32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, uint64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, int8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, int16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, int32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, int64_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, uint8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, uint16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, uint32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, uint64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, int8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, int16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, int32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, int64_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, uint8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, uint16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, uint32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, uint64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, int8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, int16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, int32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, int64_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, uint8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, uint16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, uint32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, uint64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, int8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, int16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, int32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, int64_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, uint8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, uint16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, uint32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, uint64_t>);
+}
+
+TEST(SaturatingTest, SaturatingConstructor) {
+    static_assert(std::is_convertible_v<int_sat8_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat8_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<int_sat16_t, int_sat8_t>);
+    static_assert(std::is_convertible_v<int_sat16_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat16_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<int_sat32_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, int_sat16_t>);
+    static_assert(std::is_convertible_v<int_sat32_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat32_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<int_sat64_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, int_sat32_t>);
+    static_assert(std::is_convertible_v<int_sat64_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<int_sat64_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, int_sat64_t>);
+    static_assert(std::is_convertible_v<uint_sat8_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat8_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, uint_sat8_t>);
+    static_assert(std::is_convertible_v<uint_sat16_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat16_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, uint_sat16_t>);
+    static_assert(std::is_convertible_v<uint_sat32_t, uint_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat32_t, uint_sat64_t>);
+
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, int_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, int_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, int_sat32_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, int_sat64_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, uint_sat8_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, uint_sat16_t>);
+    static_assert(is_explicitly_convertible_v<uint_sat64_t, uint_sat32_t>);
+    static_assert(std::is_convertible_v<uint_sat64_t, uint_sat64_t>);
+}
+
+TEST(SaturatingTest, Addition) {
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) + int_sat8_t(0)), int_sat8_t>);
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) + int_sat16_t(0)), int_sat16_t>);
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) + int_sat32_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) + int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) + int_sat8_t(0)), int_sat16_t>);
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) + int_sat16_t(0)), int_sat16_t>);
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) + int_sat32_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) + int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) + int_sat8_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) + int_sat16_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) + int_sat32_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) + int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) + int_sat8_t(0)), int_sat64_t>);
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) + int_sat16_t(0)), int_sat64_t>);
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) + int_sat32_t(0)), int_sat64_t>);
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) + int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) + uint_sat8_t(0)), uint_sat8_t>);
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) + uint_sat16_t(0)), uint_sat16_t>);
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) + uint_sat32_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) + uint_sat64_t(0)), uint_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) + uint_sat8_t(0)), uint_sat16_t>);
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) + uint_sat16_t(0)), uint_sat16_t>);
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) + uint_sat32_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) + uint_sat64_t(0)), uint_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) + uint_sat8_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) + uint_sat16_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) + uint_sat32_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) + uint_sat64_t(0)), uint_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) + uint_sat8_t(0)), uint_sat64_t>);
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) + uint_sat16_t(0)), uint_sat64_t>);
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) + uint_sat32_t(0)), uint_sat64_t>);
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) + uint_sat64_t(0)), uint_sat64_t>);
+}
+
+TEST(SaturatingTest, Subtraction) {
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) - int_sat8_t(0)), int_sat8_t>);
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) - int_sat16_t(0)), int_sat16_t>);
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) - int_sat32_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) - int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) - int_sat8_t(0)), int_sat16_t>);
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) - int_sat16_t(0)), int_sat16_t>);
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) - int_sat32_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) - int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) - int_sat8_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) - int_sat16_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) - int_sat32_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) - int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) - int_sat8_t(0)), int_sat64_t>);
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) - int_sat16_t(0)), int_sat64_t>);
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) - int_sat32_t(0)), int_sat64_t>);
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) - int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) - uint_sat8_t(0)), uint_sat8_t>);
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) - uint_sat16_t(0)), uint_sat16_t>);
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) - uint_sat32_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) - uint_sat64_t(0)), uint_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) - uint_sat8_t(0)), uint_sat16_t>);
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) - uint_sat16_t(0)), uint_sat16_t>);
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) - uint_sat32_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) - uint_sat64_t(0)), uint_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) - uint_sat8_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) - uint_sat16_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) - uint_sat32_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) - uint_sat64_t(0)), uint_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) - uint_sat8_t(0)), uint_sat64_t>);
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) - uint_sat16_t(0)), uint_sat64_t>);
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) - uint_sat32_t(0)), uint_sat64_t>);
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) - uint_sat64_t(0)), uint_sat64_t>);
+}
+
+TEST(SaturatingTest, Multiplication) {
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) * int_sat8_t(0)), int_sat8_t>);
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) * int_sat16_t(0)), int_sat16_t>);
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) * int_sat32_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat8_t(0) * int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) * int_sat8_t(0)), int_sat16_t>);
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) * int_sat16_t(0)), int_sat16_t>);
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) * int_sat32_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat16_t(0) * int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) * int_sat8_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) * int_sat16_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) * int_sat32_t(0)), int_sat32_t>);
+    static_assert(std::is_same_v<decltype(int_sat32_t(0) * int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) * int_sat8_t(0)), int_sat64_t>);
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) * int_sat16_t(0)), int_sat64_t>);
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) * int_sat32_t(0)), int_sat64_t>);
+    static_assert(std::is_same_v<decltype(int_sat64_t(0) * int_sat64_t(0)), int_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) * uint_sat8_t(0)), uint_sat8_t>);
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) * uint_sat16_t(0)), uint_sat16_t>);
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) * uint_sat32_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat8_t(0) * uint_sat64_t(0)), uint_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) * uint_sat8_t(0)), uint_sat16_t>);
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) * uint_sat16_t(0)), uint_sat16_t>);
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) * uint_sat32_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat16_t(0) * uint_sat64_t(0)), uint_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) * uint_sat8_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) * uint_sat16_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) * uint_sat32_t(0)), uint_sat32_t>);
+    static_assert(std::is_same_v<decltype(uint_sat32_t(0) * uint_sat64_t(0)), uint_sat64_t>);
+
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) * uint_sat8_t(0)), uint_sat64_t>);
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) * uint_sat16_t(0)), uint_sat64_t>);
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) * uint_sat32_t(0)), uint_sat64_t>);
+    static_assert(std::is_same_v<decltype(uint_sat64_t(0) * uint_sat64_t(0)), uint_sat64_t>);
+}
+
+TEST(SaturatingTest, CommonType) {
+    static_assert(std::is_same_v<std::common_type_t<int_sat8_t, int_sat8_t>, int_sat8_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat8_t, int_sat16_t>, int_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat8_t, int_sat32_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat8_t, int_sat64_t>, int_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<int_sat16_t, int_sat8_t>, int_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat16_t, int_sat16_t>, int_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat16_t, int_sat32_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat16_t, int_sat64_t>, int_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<int_sat32_t, int_sat8_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat32_t, int_sat16_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat32_t, int_sat32_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat32_t, int_sat64_t>, int_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<int_sat64_t, int_sat8_t>, int_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat64_t, int_sat16_t>, int_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat64_t, int_sat32_t>, int_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat64_t, int_sat64_t>, int_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<uint_sat8_t, uint_sat8_t>, uint_sat8_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat8_t, uint_sat16_t>, uint_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat8_t, uint_sat32_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat8_t, uint_sat64_t>, uint_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<uint_sat16_t, uint_sat8_t>, uint_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat16_t, uint_sat16_t>, uint_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat16_t, uint_sat32_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat16_t, uint_sat64_t>, uint_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<uint_sat32_t, uint_sat8_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat32_t, uint_sat16_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat32_t, uint_sat32_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat32_t, uint_sat64_t>, uint_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<uint_sat64_t, uint_sat8_t>, uint_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat64_t, uint_sat16_t>, uint_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat64_t, uint_sat32_t>, uint_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat64_t, uint_sat64_t>, uint_sat64_t>);
+}
+
+TEST(SaturatingTest, CommonTypeWithIntegral) {
+    static_assert(std::is_same_v<std::common_type_t<int_sat8_t, int8_t>, int_sat8_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat8_t, int16_t>, int_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat8_t, int32_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat8_t, int64_t>, int_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<int_sat16_t, int8_t>, int_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat16_t, int16_t>, int_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat16_t, int32_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat16_t, int64_t>, int_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<int_sat32_t, int8_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat32_t, int16_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat32_t, int32_t>, int_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat32_t, int64_t>, int_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<int_sat64_t, int8_t>, int_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat64_t, int16_t>, int_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat64_t, int32_t>, int_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<int_sat64_t, int64_t>, int_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<uint_sat8_t, uint8_t>, uint_sat8_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat8_t, uint16_t>, uint_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat8_t, uint32_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat8_t, uint64_t>, uint_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<uint_sat16_t, uint8_t>, uint_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat16_t, uint16_t>, uint_sat16_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat16_t, uint32_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat16_t, uint64_t>, uint_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<uint_sat32_t, uint8_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat32_t, uint16_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat32_t, uint32_t>, uint_sat32_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat32_t, uint64_t>, uint_sat64_t>);
+
+    static_assert(std::is_same_v<std::common_type_t<uint_sat64_t, uint8_t>, uint_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat64_t, uint16_t>, uint_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat64_t, uint32_t>, uint_sat64_t>);
+    static_assert(std::is_same_v<std::common_type_t<uint_sat64_t, uint64_t>, uint_sat64_t>);
+}
+
+namespace {
+
+template <typename T>
+constexpr inline T min_v = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr inline T minr_v = min_v<T> + T(1);
+
+template <typename T>
+constexpr inline T minrr_v = min_v<T> + T(2);
+
+template <typename T>
+constexpr inline T max_v = std::numeric_limits<T>::max();
+
+template <typename T>
+constexpr inline T maxl_v = max_v<T> - T(1);
+
+template <typename T>
+constexpr inline T maxll_v = max_v<T> - T(2);
+
+template <typename T>
+constexpr inline T zero_v = T(0);
+
+template <typename T>
+constexpr inline T zeror_v = T(1);
+
+template <typename T>
+constexpr inline T zerorr_v = T(2);
+
+template <typename T>
+constexpr inline T zerol_v = [] {
+    static_assert(std::is_signed_v<T>, "Only available for signed types");
+    return T(-1);
+}();
+
+template <typename T>
+constexpr inline T zeroll_v = [] {
+    static_assert(std::is_signed_v<T>, "Only available for signed types");
+    return T(-2);
+}();
+
+#define EXPECT_SATURATING_CAST(IntoType, FromValue, IntoValue) EXPECT_THAT(saturating_cast<IntoType>(FromValue), IntoType(IntoValue))
+
+} // namespace
+
+TEST(SaturatingCastTest, Into_8) {
+    EXPECT_SATURATING_CAST(int8_t, min_v<int8_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, minr_v<int8_t>, minr_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, max_v<int8_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, maxl_v<int8_t>, maxl_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zero_v<int8_t>, zero_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zeror_v<int8_t>, zeror_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zerol_v<int8_t>, zerol_v<int8_t>);
+
+    EXPECT_SATURATING_CAST(int8_t, min_v<int16_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, minr_v<int16_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, max_v<int16_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, maxl_v<int16_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zero_v<int16_t>, zero_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zeror_v<int16_t>, zeror_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zerol_v<int16_t>, zerol_v<int8_t>);
+
+    EXPECT_SATURATING_CAST(int8_t, min_v<int32_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, minr_v<int32_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, max_v<int32_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, maxl_v<int32_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zero_v<int32_t>, zero_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zeror_v<int32_t>, zeror_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zerol_v<int32_t>, zerol_v<int8_t>);
+
+    EXPECT_SATURATING_CAST(int8_t, min_v<int64_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, minr_v<int64_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, max_v<int64_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, maxl_v<int64_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zero_v<int64_t>, zero_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zeror_v<int64_t>, zeror_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, zerol_v<int64_t>, zerol_v<int8_t>);
+
+    EXPECT_SATURATING_CAST(int8_t, min_v<uint8_t>, zero_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, minr_v<uint8_t>, zeror_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, max_v<uint8_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, maxl_v<uint8_t>, max_v<int8_t>);
+
+    EXPECT_SATURATING_CAST(int8_t, min_v<uint16_t>, zero_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, minr_v<uint16_t>, zeror_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, max_v<uint16_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, maxl_v<uint16_t>, max_v<int8_t>);
+
+    EXPECT_SATURATING_CAST(int8_t, min_v<uint32_t>, zero_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, minr_v<uint32_t>, zeror_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, max_v<uint32_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, maxl_v<uint32_t>, max_v<int8_t>);
+
+    EXPECT_SATURATING_CAST(int8_t, min_v<uint64_t>, zero_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, minr_v<uint64_t>, zeror_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, max_v<uint64_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int8_t, maxl_v<uint64_t>, max_v<int8_t>);
+
+    EXPECT_SATURATING_CAST(uint8_t, min_v<int8_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, minr_v<int8_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, max_v<int8_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, maxl_v<int8_t>, maxl_v<int8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zero_v<int8_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zeror_v<int8_t>, zeror_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zerol_v<int8_t>, zero_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint8_t, min_v<int16_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, minr_v<int16_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, max_v<int16_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, maxl_v<int16_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zero_v<int16_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zeror_v<int16_t>, zeror_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zerol_v<int16_t>, zero_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint8_t, min_v<int32_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, minr_v<int32_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, max_v<int32_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, maxl_v<int32_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zero_v<int32_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zeror_v<int32_t>, zeror_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zerol_v<int32_t>, zero_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint8_t, min_v<int64_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, minr_v<int64_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, max_v<int64_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, maxl_v<int64_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zero_v<int64_t>, zero_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zeror_v<int64_t>, zeror_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, zerol_v<int64_t>, zero_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint8_t, min_v<uint8_t>, min_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, minr_v<uint8_t>, minr_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, max_v<uint8_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, maxl_v<uint8_t>, maxl_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint8_t, min_v<uint16_t>, min_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, minr_v<uint16_t>, minr_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, max_v<uint16_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, maxl_v<uint16_t>, max_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint8_t, min_v<uint32_t>, min_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, minr_v<uint32_t>, minr_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, max_v<uint32_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, maxl_v<uint32_t>, max_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint8_t, min_v<uint64_t>, min_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, minr_v<uint64_t>, minr_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, max_v<uint64_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint8_t, maxl_v<uint64_t>, max_v<uint8_t>);
+}
+
+TEST(SaturatingCastTest, Into_16) {
+    EXPECT_SATURATING_CAST(int16_t, min_v<int8_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int16_t, minr_v<int8_t>, minr_v<int8_t>);
+    EXPECT_SATURATING_CAST(int16_t, max_v<int8_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int16_t, maxl_v<int8_t>, maxl_v<int8_t>);
+    EXPECT_SATURATING_CAST(int16_t, zero_v<int8_t>, zero_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zeror_v<int8_t>, zeror_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zerol_v<int8_t>, zerol_v<int16_t>);
+
+    EXPECT_SATURATING_CAST(int16_t, min_v<int16_t>, min_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, minr_v<int16_t>, minr_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, max_v<int16_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, maxl_v<int16_t>, maxl_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zero_v<int16_t>, zero_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zeror_v<int16_t>, zeror_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zerol_v<int16_t>, zerol_v<int16_t>);
+
+    EXPECT_SATURATING_CAST(int16_t, min_v<int32_t>, min_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, minr_v<int32_t>, min_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, max_v<int32_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, maxl_v<int32_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zero_v<int32_t>, zero_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zeror_v<int32_t>, zeror_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zerol_v<int32_t>, zerol_v<int16_t>);
+
+    EXPECT_SATURATING_CAST(int16_t, min_v<int64_t>, min_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, minr_v<int64_t>, min_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, max_v<int64_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, maxl_v<int64_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zero_v<int64_t>, zero_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zeror_v<int64_t>, zeror_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, zerol_v<int64_t>, zerol_v<int16_t>);
+
+    EXPECT_SATURATING_CAST(int16_t, min_v<uint8_t>, zero_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, minr_v<uint8_t>, zeror_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, max_v<uint8_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(int16_t, maxl_v<uint8_t>, maxl_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(int16_t, min_v<uint16_t>, zero_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, minr_v<uint16_t>, zeror_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, max_v<uint16_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, maxl_v<uint16_t>, max_v<int16_t>);
+
+    EXPECT_SATURATING_CAST(int16_t, min_v<uint32_t>, zero_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, minr_v<uint32_t>, zeror_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, max_v<uint32_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, maxl_v<uint32_t>, max_v<int16_t>);
+
+    EXPECT_SATURATING_CAST(int16_t, min_v<uint64_t>, zero_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, minr_v<uint64_t>, zeror_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, max_v<uint64_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int16_t, maxl_v<uint64_t>, max_v<int16_t>);
+
+    EXPECT_SATURATING_CAST(uint16_t, min_v<int8_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, minr_v<int8_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, max_v<int8_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(uint16_t, maxl_v<int8_t>, maxl_v<int8_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zero_v<int8_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zeror_v<int8_t>, zeror_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zerol_v<int8_t>, zero_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(uint16_t, min_v<int16_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, minr_v<int16_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, max_v<int16_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, maxl_v<int16_t>, maxl_v<int16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zero_v<int16_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zeror_v<int16_t>, zeror_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zerol_v<int16_t>, zero_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(uint16_t, min_v<int32_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, minr_v<int32_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, max_v<int32_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, maxl_v<int32_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zero_v<int32_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zeror_v<int32_t>, zeror_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zerol_v<int32_t>, zero_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(uint16_t, min_v<int64_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, minr_v<int64_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, max_v<int64_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, maxl_v<int64_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zero_v<int64_t>, zero_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zeror_v<int64_t>, zeror_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, zerol_v<int64_t>, zero_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(uint16_t, min_v<uint8_t>, min_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, minr_v<uint8_t>, minr_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, max_v<uint8_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint16_t, maxl_v<uint8_t>, maxl_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint16_t, min_v<uint16_t>, min_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, minr_v<uint16_t>, minr_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, max_v<uint16_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, maxl_v<uint16_t>, maxl_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(uint16_t, min_v<uint32_t>, min_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, minr_v<uint32_t>, minr_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, max_v<uint32_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, maxl_v<uint32_t>, max_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(uint16_t, min_v<uint64_t>, min_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, minr_v<uint64_t>, minr_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, max_v<uint64_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint16_t, maxl_v<uint64_t>, max_v<uint16_t>);
+}
+
+TEST(SaturatingCastTest, Into_32) {
+    EXPECT_SATURATING_CAST(int32_t, min_v<int8_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int32_t, minr_v<int8_t>, minr_v<int8_t>);
+    EXPECT_SATURATING_CAST(int32_t, max_v<int8_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int32_t, maxl_v<int8_t>, maxl_v<int8_t>);
+    EXPECT_SATURATING_CAST(int32_t, zero_v<int8_t>, zero_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zeror_v<int8_t>, zeror_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zerol_v<int8_t>, zerol_v<int32_t>);
+
+    EXPECT_SATURATING_CAST(int32_t, min_v<int16_t>, min_v<int16_t>);
+    EXPECT_SATURATING_CAST(int32_t, minr_v<int16_t>, minr_v<int16_t>);
+    EXPECT_SATURATING_CAST(int32_t, max_v<int16_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int32_t, maxl_v<int16_t>, maxl_v<int16_t>);
+    EXPECT_SATURATING_CAST(int32_t, zero_v<int16_t>, zero_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zeror_v<int16_t>, zeror_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zerol_v<int16_t>, zerol_v<int32_t>);
+
+    EXPECT_SATURATING_CAST(int32_t, min_v<int32_t>, min_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, minr_v<int32_t>, minr_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, max_v<int32_t>, max_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, maxl_v<int32_t>, maxl_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zero_v<int32_t>, zero_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zeror_v<int32_t>, zeror_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zerol_v<int32_t>, zerol_v<int32_t>);
+
+    EXPECT_SATURATING_CAST(int32_t, min_v<int64_t>, min_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, minr_v<int64_t>, min_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, max_v<int64_t>, max_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, maxl_v<int64_t>, max_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zero_v<int64_t>, zero_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zeror_v<int64_t>, zeror_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, zerol_v<int64_t>, zerol_v<int32_t>);
+
+    EXPECT_SATURATING_CAST(int32_t, min_v<uint8_t>, zero_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, minr_v<uint8_t>, zeror_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, max_v<uint8_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(int32_t, maxl_v<uint8_t>, maxl_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(int32_t, min_v<uint16_t>, zero_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, minr_v<uint16_t>, zeror_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, max_v<uint16_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(int32_t, maxl_v<uint16_t>, maxl_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(int32_t, min_v<uint32_t>, zero_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, minr_v<uint32_t>, zeror_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, max_v<uint32_t>, max_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, maxl_v<uint32_t>, max_v<int32_t>);
+
+    EXPECT_SATURATING_CAST(int32_t, min_v<uint64_t>, zero_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, minr_v<uint64_t>, zeror_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, max_v<uint64_t>, max_v<int32_t>);
+    EXPECT_SATURATING_CAST(int32_t, maxl_v<uint64_t>, max_v<int32_t>);
+
+    EXPECT_SATURATING_CAST(uint32_t, min_v<int8_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, minr_v<int8_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, max_v<int8_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(uint32_t, maxl_v<int8_t>, maxl_v<int8_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zero_v<int8_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zeror_v<int8_t>, zeror_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zerol_v<int8_t>, zero_v<uint32_t>);
+
+    EXPECT_SATURATING_CAST(uint32_t, min_v<int16_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, minr_v<int16_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, max_v<int16_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(uint32_t, maxl_v<int16_t>, maxl_v<int16_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zero_v<int16_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zeror_v<int16_t>, zeror_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zerol_v<int16_t>, zero_v<uint32_t>);
+
+    EXPECT_SATURATING_CAST(uint32_t, min_v<int32_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, minr_v<int32_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, max_v<int32_t>, max_v<int32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, maxl_v<int32_t>, maxl_v<int32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zero_v<int32_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zeror_v<int32_t>, zeror_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zerol_v<int32_t>, zero_v<uint32_t>);
+
+    EXPECT_SATURATING_CAST(uint32_t, min_v<int64_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, minr_v<int64_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, max_v<int64_t>, max_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, maxl_v<int64_t>, max_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zero_v<int64_t>, zero_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zeror_v<int64_t>, zeror_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, zerol_v<int64_t>, zero_v<uint32_t>);
+
+    EXPECT_SATURATING_CAST(uint32_t, min_v<uint8_t>, min_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, minr_v<uint8_t>, minr_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, max_v<uint8_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint32_t, maxl_v<uint8_t>, maxl_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint32_t, min_v<uint16_t>, min_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, minr_v<uint16_t>, minr_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, max_v<uint16_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint32_t, maxl_v<uint16_t>, maxl_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(uint32_t, min_v<uint32_t>, min_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, minr_v<uint32_t>, minr_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, max_v<uint32_t>, max_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, maxl_v<uint32_t>, maxl_v<uint32_t>);
+
+    EXPECT_SATURATING_CAST(uint32_t, min_v<uint64_t>, min_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, minr_v<uint64_t>, minr_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, max_v<uint64_t>, max_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint32_t, maxl_v<uint64_t>, max_v<uint32_t>);
+}
+
+TEST(SaturatingCastTest, Into_64) {
+    EXPECT_SATURATING_CAST(int64_t, min_v<int8_t>, min_v<int8_t>);
+    EXPECT_SATURATING_CAST(int64_t, minr_v<int8_t>, minr_v<int8_t>);
+    EXPECT_SATURATING_CAST(int64_t, max_v<int8_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(int64_t, maxl_v<int8_t>, maxl_v<int8_t>);
+    EXPECT_SATURATING_CAST(int64_t, zero_v<int8_t>, zero_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, zeror_v<int8_t>, zeror_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, zerol_v<int8_t>, zerol_v<int64_t>);
+
+    EXPECT_SATURATING_CAST(int64_t, min_v<int16_t>, min_v<int16_t>);
+    EXPECT_SATURATING_CAST(int64_t, minr_v<int16_t>, minr_v<int16_t>);
+    EXPECT_SATURATING_CAST(int64_t, max_v<int16_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(int64_t, maxl_v<int16_t>, maxl_v<int16_t>);
+    EXPECT_SATURATING_CAST(int64_t, zero_v<int16_t>, zero_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, zeror_v<int16_t>, zeror_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, zerol_v<int16_t>, zerol_v<int64_t>);
+
+    EXPECT_SATURATING_CAST(int64_t, min_v<int32_t>, min_v<int32_t>);
+    EXPECT_SATURATING_CAST(int64_t, minr_v<int32_t>, minr_v<int32_t>);
+    EXPECT_SATURATING_CAST(int64_t, max_v<int32_t>, max_v<int32_t>);
+    EXPECT_SATURATING_CAST(int64_t, maxl_v<int32_t>, maxl_v<int32_t>);
+    EXPECT_SATURATING_CAST(int64_t, zero_v<int32_t>, zero_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, zeror_v<int32_t>, zeror_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, zerol_v<int32_t>, zerol_v<int64_t>);
+
+    EXPECT_SATURATING_CAST(int64_t, min_v<int64_t>, min_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, minr_v<int64_t>, minr_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, max_v<int64_t>, max_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, maxl_v<int64_t>, maxl_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, zero_v<int64_t>, zero_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, zeror_v<int64_t>, zeror_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, zerol_v<int64_t>, zerol_v<int64_t>);
+
+    EXPECT_SATURATING_CAST(int64_t, min_v<uint8_t>, zero_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, minr_v<uint8_t>, zeror_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, max_v<uint8_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(int64_t, maxl_v<uint8_t>, maxl_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(int64_t, min_v<uint16_t>, zero_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, minr_v<uint16_t>, zeror_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, max_v<uint16_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(int64_t, maxl_v<uint16_t>, maxl_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(int64_t, min_v<uint32_t>, zero_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, minr_v<uint32_t>, zeror_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, max_v<uint32_t>, max_v<uint32_t>);
+    EXPECT_SATURATING_CAST(int64_t, maxl_v<uint32_t>, maxl_v<uint32_t>);
+
+    EXPECT_SATURATING_CAST(int64_t, min_v<uint64_t>, zero_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, minr_v<uint64_t>, zeror_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, max_v<uint64_t>, max_v<int64_t>);
+    EXPECT_SATURATING_CAST(int64_t, maxl_v<uint64_t>, max_v<int64_t>);
+
+    EXPECT_SATURATING_CAST(uint64_t, min_v<int8_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, minr_v<int8_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, max_v<int8_t>, max_v<int8_t>);
+    EXPECT_SATURATING_CAST(uint64_t, maxl_v<int8_t>, maxl_v<int8_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zero_v<int8_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zeror_v<int8_t>, zeror_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zerol_v<int8_t>, zero_v<uint64_t>);
+
+    EXPECT_SATURATING_CAST(uint64_t, min_v<int16_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, minr_v<int16_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, max_v<int16_t>, max_v<int16_t>);
+    EXPECT_SATURATING_CAST(uint64_t, maxl_v<int16_t>, maxl_v<int16_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zero_v<int16_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zeror_v<int16_t>, zeror_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zerol_v<int16_t>, zero_v<uint64_t>);
+
+    EXPECT_SATURATING_CAST(uint64_t, min_v<int32_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, minr_v<int32_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, max_v<int32_t>, max_v<int32_t>);
+    EXPECT_SATURATING_CAST(uint64_t, maxl_v<int32_t>, maxl_v<int32_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zero_v<int32_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zeror_v<int32_t>, zeror_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zerol_v<int32_t>, zero_v<uint64_t>);
+
+    EXPECT_SATURATING_CAST(uint64_t, min_v<int64_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, minr_v<int64_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, max_v<int64_t>, max_v<int64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, maxl_v<int64_t>, maxl_v<int64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zero_v<int64_t>, zero_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zeror_v<int64_t>, zeror_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, zerol_v<int64_t>, zero_v<uint64_t>);
+
+    EXPECT_SATURATING_CAST(uint64_t, min_v<uint8_t>, min_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, minr_v<uint8_t>, minr_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, max_v<uint8_t>, max_v<uint8_t>);
+    EXPECT_SATURATING_CAST(uint64_t, maxl_v<uint8_t>, maxl_v<uint8_t>);
+
+    EXPECT_SATURATING_CAST(uint64_t, min_v<uint16_t>, min_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, minr_v<uint16_t>, minr_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, max_v<uint16_t>, max_v<uint16_t>);
+    EXPECT_SATURATING_CAST(uint64_t, maxl_v<uint16_t>, maxl_v<uint16_t>);
+
+    EXPECT_SATURATING_CAST(uint64_t, min_v<uint32_t>, min_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, minr_v<uint32_t>, minr_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, max_v<uint32_t>, max_v<uint32_t>);
+    EXPECT_SATURATING_CAST(uint64_t, maxl_v<uint32_t>, maxl_v<uint32_t>);
+
+    EXPECT_SATURATING_CAST(uint64_t, min_v<uint64_t>, min_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, minr_v<uint64_t>, minr_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, max_v<uint64_t>, max_v<uint64_t>);
+    EXPECT_SATURATING_CAST(uint64_t, maxl_v<uint64_t>, maxl_v<uint64_t>);
+}
+
+TEST(SaturatingAddTest, Test_8_8) {
+    EXPECT_THAT(saturating_add(min_v<int8_t>, min_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, minr_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, max_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, maxl_v<int8_t>), int8_t(zeroll_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zero_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zeror_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zerol_v<int8_t>), int8_t(min_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, min_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, minr_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, max_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, maxl_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zero_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zeror_v<int8_t>), int8_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zerol_v<int8_t>), int8_t(min_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int8_t>, min_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, minr_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, max_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, maxl_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zero_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zeror_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zerol_v<int8_t>), int8_t(maxl_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, min_v<int8_t>), int8_t(zeroll_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, minr_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, max_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, maxl_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zero_v<int8_t>), int8_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zeror_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zerol_v<int8_t>), int8_t(maxll_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, min_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, minr_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, max_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, maxl_v<int8_t>), int8_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zero_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zeror_v<int8_t>), int8_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zerol_v<int8_t>), int8_t(zerol_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, min_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, minr_v<int8_t>), int8_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, max_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, maxl_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zero_v<int8_t>), int8_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zeror_v<int8_t>), int8_t(zerorr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zerol_v<int8_t>), int8_t(zero_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, min_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, minr_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, max_v<int8_t>), int8_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, maxl_v<int8_t>), int8_t(maxll_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zero_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zeror_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zerol_v<int8_t>), int8_t(zeroll_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, min_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, minr_v<uint8_t>), uint8_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, max_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, maxl_v<uint8_t>), uint8_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, min_v<uint8_t>), uint8_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, minr_v<uint8_t>), uint8_t(minrr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, max_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, maxl_v<uint8_t>), uint8_t(max_v<uint8_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, min_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, minr_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, max_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, maxl_v<uint8_t>), uint8_t(max_v<uint8_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, min_v<uint8_t>), uint8_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, minr_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, max_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, maxl_v<uint8_t>), uint8_t(max_v<uint8_t>));
+}
+
+TEST(SaturatingAddTest, Test_8_16) {
+    EXPECT_THAT(saturating_add(min_v<int8_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, max_v<int16_t>), int16_t(min_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_add(min_v<int8_t>, maxl_v<int16_t>), int16_t(min_v<int8_t>) + maxl_v<int16_t>);
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zero_v<int16_t>), int16_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zeror_v<int16_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zerol_v<int16_t>), int16_t(min_v<int8_t>) + zerol_v<int16_t>);
+
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, max_v<int16_t>), int16_t(minr_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, maxl_v<int16_t>), int16_t(minr_v<int8_t>) + maxl_v<int16_t>);
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zero_v<int16_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zeror_v<int16_t>), int16_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zerol_v<int16_t>), int16_t(min_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int8_t>, min_v<int16_t>), int16_t(max_v<int8_t>) + min_v<int16_t>);
+    EXPECT_THAT(saturating_add(max_v<int8_t>, minr_v<int16_t>), int16_t(max_v<int8_t>) + minr_v<int16_t>);
+    EXPECT_THAT(saturating_add(max_v<int8_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zero_v<int16_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zeror_v<int16_t>), int16_t(max_v<int8_t>) + zeror_v<int16_t>);
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zerol_v<int16_t>), int16_t(maxl_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, min_v<int16_t>), int16_t(maxl_v<int8_t>) + min_v<int16_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, minr_v<int16_t>), int16_t(maxl_v<int8_t>) + minr_v<int16_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zero_v<int16_t>), int16_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zeror_v<int16_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zerol_v<int16_t>), int16_t(maxll_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, minr_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, maxl_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zeror_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zerol_v<int16_t>), int16_t(zerol_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, min_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, minr_v<int16_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zero_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zeror_v<int16_t>), int16_t(zerorr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zerol_v<int16_t>), int16_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, max_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, maxl_v<int16_t>), int16_t(maxll_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zero_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zeror_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zerol_v<int16_t>), int16_t(zeroll_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, minr_v<uint16_t>), uint16_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, maxl_v<uint16_t>), uint16_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, min_v<uint16_t>), uint16_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, minr_v<uint16_t>), uint16_t(minrr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, min_v<uint16_t>), uint16_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, minr_v<uint16_t>), uint16_t(max_v<uint8_t>) + zeror_v<uint16_t>);
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, min_v<uint16_t>), uint16_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, minr_v<uint16_t>), uint16_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+}
+
+TEST(SaturatingAddTest, Test_8_32) {
+    EXPECT_THAT(saturating_add(min_v<int8_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, max_v<int32_t>), int32_t(min_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_add(min_v<int8_t>, maxl_v<int32_t>), int32_t(min_v<int8_t>) + maxl_v<int32_t>);
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zero_v<int32_t>), int32_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zeror_v<int32_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zerol_v<int32_t>), int32_t(min_v<int8_t>) + zerol_v<int32_t>);
+
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, max_v<int32_t>), int32_t(minr_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, maxl_v<int32_t>), int32_t(minr_v<int8_t>) + maxl_v<int32_t>);
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zero_v<int32_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zeror_v<int32_t>), int32_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zerol_v<int32_t>), int32_t(min_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int8_t>, min_v<int32_t>), int32_t(max_v<int8_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int8_t>, minr_v<int32_t>), int32_t(max_v<int8_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int8_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zero_v<int32_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zeror_v<int32_t>), int32_t(max_v<int8_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zerol_v<int32_t>), int32_t(maxl_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, min_v<int32_t>), int32_t(maxl_v<int8_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, minr_v<int32_t>), int32_t(maxl_v<int8_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zero_v<int32_t>), int32_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zeror_v<int32_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zerol_v<int32_t>), int32_t(maxll_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, minr_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, maxl_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zeror_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zerol_v<int32_t>), int32_t(zerol_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, min_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, minr_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zero_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zeror_v<int32_t>), int32_t(zerorr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zerol_v<int32_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, max_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, maxl_v<int32_t>), int32_t(maxll_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zero_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zeror_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zerol_v<int32_t>), int32_t(zeroll_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, minr_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, maxl_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, min_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, minr_v<uint32_t>), uint32_t(minrr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, min_v<uint32_t>), uint32_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, minr_v<uint32_t>), uint32_t(max_v<uint8_t>) + zeror_v<uint32_t>);
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, min_v<uint32_t>), uint32_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, minr_v<uint32_t>), uint32_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingAddTest, Test_8_64) {
+    EXPECT_THAT(saturating_add(min_v<int8_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, max_v<int64_t>), int64_t(min_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int8_t>, maxl_v<int64_t>), int64_t(min_v<int8_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zero_v<int64_t>), int64_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zeror_v<int64_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(min_v<int8_t>, zerol_v<int64_t>), int64_t(min_v<int8_t>) + zerol_v<int64_t>);
+
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, max_v<int64_t>), int64_t(minr_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, maxl_v<int64_t>), int64_t(minr_v<int8_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zero_v<int64_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zeror_v<int64_t>), int64_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_add(minr_v<int8_t>, zerol_v<int64_t>), int64_t(min_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int8_t>, min_v<int64_t>), int64_t(max_v<int8_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int8_t>, minr_v<int64_t>), int64_t(max_v<int8_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int8_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zero_v<int64_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zeror_v<int64_t>), int64_t(max_v<int8_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int8_t>, zerol_v<int64_t>), int64_t(maxl_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, min_v<int64_t>), int64_t(maxl_v<int8_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, minr_v<int64_t>), int64_t(maxl_v<int8_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zero_v<int64_t>), int64_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zeror_v<int64_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int8_t>, zerol_v<int64_t>), int64_t(maxll_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, minr_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, maxl_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zeror_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int8_t>, zerol_v<int64_t>), int64_t(zerol_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, min_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, minr_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zero_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zeror_v<int64_t>), int64_t(zerorr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int8_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, max_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, maxl_v<int64_t>), int64_t(maxll_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zero_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int8_t>, zerol_v<int64_t>), int64_t(zeroll_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, minr_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint8_t>, maxl_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, min_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, minr_v<uint64_t>), uint64_t(minrr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint8_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, min_v<uint64_t>), uint64_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, minr_v<uint64_t>), uint64_t(max_v<uint8_t>) + zeror_v<uint64_t>);
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint8_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, min_v<uint64_t>), uint64_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, minr_v<uint64_t>), uint64_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint8_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingAddTest, Test_16_8) {
+    EXPECT_THAT(saturating_add(min_v<int16_t>, min_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, minr_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, max_v<int8_t>), int16_t(max_v<int8_t>) + min_v<int16_t>);
+    EXPECT_THAT(saturating_add(min_v<int16_t>, maxl_v<int8_t>), int16_t(maxl_v<int8_t>) + min_v<int16_t>);
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zero_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zeror_v<int8_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zerol_v<int8_t>), int16_t(min_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, min_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, minr_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, max_v<int8_t>), int16_t(max_v<int8_t>) + minr_v<int16_t>);
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, maxl_v<int8_t>), int16_t(maxl_v<int8_t>) + minr_v<int16_t>);
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zero_v<int8_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zeror_v<int8_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zerol_v<int8_t>), int16_t(min_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int16_t>, min_v<int8_t>), int16_t(min_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_add(max_v<int16_t>, minr_v<int8_t>), int16_t(minr_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_add(max_v<int16_t>, max_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, maxl_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zero_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zeror_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zerol_v<int8_t>), int16_t(maxl_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, min_v<int8_t>), int16_t(min_v<int8_t>) + maxl_v<int16_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, minr_v<int8_t>), int16_t(minr_v<int8_t>) + maxl_v<int16_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, max_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, maxl_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zero_v<int8_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zeror_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zerol_v<int8_t>), int16_t(maxll_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, min_v<int8_t>), int16_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, minr_v<int8_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, max_v<int8_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, maxl_v<int8_t>), int16_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zero_v<int8_t>), int16_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zeror_v<int8_t>), int16_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zerol_v<int8_t>), int16_t(zerol_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, min_v<int8_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, minr_v<int8_t>), int16_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, max_v<int8_t>), int16_t(max_v<int8_t>) + zeror_v<int16_t>);
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, maxl_v<int8_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zero_v<int8_t>), int16_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zeror_v<int8_t>), int16_t(zerorr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zerol_v<int8_t>), int16_t(zero_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, min_v<int8_t>), int16_t(min_v<int8_t>) + zerol_v<int16_t>);
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, minr_v<int8_t>), int16_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, max_v<int8_t>), int16_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, maxl_v<int8_t>), int16_t(maxll_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zero_v<int8_t>), int16_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zeror_v<int8_t>), int16_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zerol_v<int8_t>), int16_t(zeroll_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, min_v<uint8_t>), uint16_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, minr_v<uint8_t>), uint16_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, max_v<uint8_t>), uint16_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, maxl_v<uint8_t>), uint16_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, min_v<uint8_t>), uint16_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, minr_v<uint8_t>), uint16_t(minrr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, max_v<uint8_t>), uint16_t(max_v<uint8_t>) + zeror_v<uint16_t>);
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, maxl_v<uint8_t>), uint16_t(max_v<uint8_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, min_v<uint8_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, minr_v<uint8_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, max_v<uint8_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, maxl_v<uint8_t>), uint16_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, min_v<uint8_t>), uint16_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, minr_v<uint8_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, max_v<uint8_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, maxl_v<uint8_t>), uint16_t(max_v<uint16_t>));
+}
+
+TEST(SaturatingAddTest, Test_16_16) {
+    EXPECT_THAT(saturating_add(min_v<int16_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, max_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, maxl_v<int16_t>), int16_t(zeroll_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zero_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zeror_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zerol_v<int16_t>), int16_t(min_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, max_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, maxl_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zero_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zeror_v<int16_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zerol_v<int16_t>), int16_t(min_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int16_t>, min_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, minr_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zero_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zeror_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zerol_v<int16_t>), int16_t(maxl_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, min_v<int16_t>), int16_t(zeroll_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, minr_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zero_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zeror_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zerol_v<int16_t>), int16_t(maxll_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, minr_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, maxl_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zeror_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zerol_v<int16_t>), int16_t(zerol_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, min_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, minr_v<int16_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zero_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zeror_v<int16_t>), int16_t(zerorr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zerol_v<int16_t>), int16_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, max_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, maxl_v<int16_t>), int16_t(maxll_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zero_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zeror_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zerol_v<int16_t>), int16_t(zeroll_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, minr_v<uint16_t>), uint16_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, maxl_v<uint16_t>), uint16_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, min_v<uint16_t>), uint16_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, minr_v<uint16_t>), uint16_t(minrr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, min_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, minr_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, min_v<uint16_t>), uint16_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, minr_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+}
+
+TEST(SaturatingAddTest, Test_16_32) {
+    EXPECT_THAT(saturating_add(min_v<int16_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, max_v<int32_t>), int32_t(min_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_add(min_v<int16_t>, maxl_v<int32_t>), int32_t(min_v<int16_t>) + maxl_v<int32_t>);
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zero_v<int32_t>), int32_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zeror_v<int32_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zerol_v<int32_t>), int32_t(min_v<int16_t>) + zerol_v<int32_t>);
+
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, max_v<int32_t>), int32_t(minr_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, maxl_v<int32_t>), int32_t(minr_v<int16_t>) + maxl_v<int32_t>);
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zero_v<int32_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zeror_v<int32_t>), int32_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zerol_v<int32_t>), int32_t(min_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int16_t>, min_v<int32_t>), int32_t(max_v<int16_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int16_t>, minr_v<int32_t>), int32_t(max_v<int16_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int16_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zero_v<int32_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zeror_v<int32_t>), int32_t(max_v<int16_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zerol_v<int32_t>), int32_t(maxl_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, min_v<int32_t>), int32_t(maxl_v<int16_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, minr_v<int32_t>), int32_t(maxl_v<int16_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zero_v<int32_t>), int32_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zeror_v<int32_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zerol_v<int32_t>), int32_t(maxll_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, minr_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, maxl_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zeror_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zerol_v<int32_t>), int32_t(zerol_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, min_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, minr_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zero_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zeror_v<int32_t>), int32_t(zerorr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zerol_v<int32_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, max_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, maxl_v<int32_t>), int32_t(maxll_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zero_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zeror_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zerol_v<int32_t>), int32_t(zeroll_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, minr_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, maxl_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, min_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, minr_v<uint32_t>), uint32_t(minrr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, min_v<uint32_t>), uint32_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, minr_v<uint32_t>), uint32_t(max_v<uint16_t>) + zeror_v<uint32_t>);
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, min_v<uint32_t>), uint32_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, minr_v<uint32_t>), uint32_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingAddTest, Test_16_64) {
+    EXPECT_THAT(saturating_add(min_v<int16_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, max_v<int64_t>), int64_t(min_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int16_t>, maxl_v<int64_t>), int64_t(min_v<int16_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zero_v<int64_t>), int64_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zeror_v<int64_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(min_v<int16_t>, zerol_v<int64_t>), int64_t(min_v<int16_t>) + zerol_v<int64_t>);
+
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, max_v<int64_t>), int64_t(minr_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, maxl_v<int64_t>), int64_t(minr_v<int16_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zero_v<int64_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zeror_v<int64_t>), int64_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_add(minr_v<int16_t>, zerol_v<int64_t>), int64_t(min_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int16_t>, min_v<int64_t>), int64_t(max_v<int16_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int16_t>, minr_v<int64_t>), int64_t(max_v<int16_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int16_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zero_v<int64_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zeror_v<int64_t>), int64_t(max_v<int16_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int16_t>, zerol_v<int64_t>), int64_t(maxl_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, min_v<int64_t>), int64_t(maxl_v<int16_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, minr_v<int64_t>), int64_t(maxl_v<int16_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zero_v<int64_t>), int64_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zeror_v<int64_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int16_t>, zerol_v<int64_t>), int64_t(maxll_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, minr_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, maxl_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zeror_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int16_t>, zerol_v<int64_t>), int64_t(zerol_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, min_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, minr_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zero_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zeror_v<int64_t>), int64_t(zerorr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int16_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, max_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, maxl_v<int64_t>), int64_t(maxll_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zero_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int16_t>, zerol_v<int64_t>), int64_t(zeroll_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, minr_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint16_t>, maxl_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, min_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, minr_v<uint64_t>), uint64_t(minrr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint16_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, min_v<uint64_t>), uint64_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, minr_v<uint64_t>), uint64_t(max_v<uint16_t>) + zeror_v<uint64_t>);
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint16_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, min_v<uint64_t>), uint64_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, minr_v<uint64_t>), uint64_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint16_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingAddTest, Test_32_8) {
+    EXPECT_THAT(saturating_add(min_v<int32_t>, min_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, minr_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, max_v<int8_t>), int32_t(max_v<int8_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_add(min_v<int32_t>, maxl_v<int8_t>), int32_t(maxl_v<int8_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zero_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zeror_v<int8_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zerol_v<int8_t>), int32_t(min_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, min_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, minr_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, max_v<int8_t>), int32_t(max_v<int8_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, maxl_v<int8_t>), int32_t(maxl_v<int8_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zero_v<int8_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zeror_v<int8_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zerol_v<int8_t>), int32_t(min_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int32_t>, min_v<int8_t>), int32_t(min_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int32_t>, minr_v<int8_t>), int32_t(minr_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int32_t>, max_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, maxl_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zero_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zeror_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zerol_v<int8_t>), int32_t(maxl_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, min_v<int8_t>), int32_t(min_v<int8_t>) + maxl_v<int32_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, minr_v<int8_t>), int32_t(minr_v<int8_t>) + maxl_v<int32_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, max_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, maxl_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zero_v<int8_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zeror_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zerol_v<int8_t>), int32_t(maxll_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, min_v<int8_t>), int32_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, minr_v<int8_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, max_v<int8_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, maxl_v<int8_t>), int32_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zero_v<int8_t>), int32_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zeror_v<int8_t>), int32_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zerol_v<int8_t>), int32_t(zerol_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, min_v<int8_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, minr_v<int8_t>), int32_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, max_v<int8_t>), int32_t(max_v<int8_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, maxl_v<int8_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zero_v<int8_t>), int32_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zeror_v<int8_t>), int32_t(zerorr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zerol_v<int8_t>), int32_t(zero_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, min_v<int8_t>), int32_t(min_v<int8_t>) + zerol_v<int32_t>);
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, minr_v<int8_t>), int32_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, max_v<int8_t>), int32_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, maxl_v<int8_t>), int32_t(maxll_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zero_v<int8_t>), int32_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zeror_v<int8_t>), int32_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zerol_v<int8_t>), int32_t(zeroll_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, min_v<uint8_t>), uint32_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, minr_v<uint8_t>), uint32_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, max_v<uint8_t>), uint32_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, maxl_v<uint8_t>), uint32_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, min_v<uint8_t>), uint32_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, minr_v<uint8_t>), uint32_t(minrr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, max_v<uint8_t>), uint32_t(max_v<uint8_t>) + zeror_v<uint32_t>);
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, maxl_v<uint8_t>), uint32_t(max_v<uint8_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, min_v<uint8_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, minr_v<uint8_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, max_v<uint8_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, maxl_v<uint8_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, min_v<uint8_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, minr_v<uint8_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, max_v<uint8_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, maxl_v<uint8_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingAddTest, Test_32_16) {
+    EXPECT_THAT(saturating_add(min_v<int32_t>, min_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, minr_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, max_v<int16_t>), int32_t(max_v<int16_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_add(min_v<int32_t>, maxl_v<int16_t>), int32_t(maxl_v<int16_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zero_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zeror_v<int16_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zerol_v<int16_t>), int32_t(min_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, min_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, minr_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, max_v<int16_t>), int32_t(max_v<int16_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, maxl_v<int16_t>), int32_t(maxl_v<int16_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zero_v<int16_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zeror_v<int16_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zerol_v<int16_t>), int32_t(min_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int32_t>, min_v<int16_t>), int32_t(min_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int32_t>, minr_v<int16_t>), int32_t(minr_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_add(max_v<int32_t>, max_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, maxl_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zero_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zeror_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zerol_v<int16_t>), int32_t(maxl_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, min_v<int16_t>), int32_t(min_v<int16_t>) + maxl_v<int32_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, minr_v<int16_t>), int32_t(minr_v<int16_t>) + maxl_v<int32_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, max_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, maxl_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zero_v<int16_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zeror_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zerol_v<int16_t>), int32_t(maxll_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, min_v<int16_t>), int32_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, minr_v<int16_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, max_v<int16_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, maxl_v<int16_t>), int32_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zero_v<int16_t>), int32_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zeror_v<int16_t>), int32_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zerol_v<int16_t>), int32_t(zerol_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, min_v<int16_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, minr_v<int16_t>), int32_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, max_v<int16_t>), int32_t(max_v<int16_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, maxl_v<int16_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zero_v<int16_t>), int32_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zeror_v<int16_t>), int32_t(zerorr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zerol_v<int16_t>), int32_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, min_v<int16_t>), int32_t(min_v<int16_t>) + zerol_v<int32_t>);
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, minr_v<int16_t>), int32_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, max_v<int16_t>), int32_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, maxl_v<int16_t>), int32_t(maxll_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zero_v<int16_t>), int32_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zeror_v<int16_t>), int32_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zerol_v<int16_t>), int32_t(zeroll_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, min_v<uint16_t>), uint32_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, minr_v<uint16_t>), uint32_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, max_v<uint16_t>), uint32_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, maxl_v<uint16_t>), uint32_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, min_v<uint16_t>), uint32_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, minr_v<uint16_t>), uint32_t(minrr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, max_v<uint16_t>), uint32_t(max_v<uint16_t>) + zeror_v<uint32_t>);
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, maxl_v<uint16_t>), uint32_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, min_v<uint16_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, minr_v<uint16_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, max_v<uint16_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, maxl_v<uint16_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, min_v<uint16_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, minr_v<uint16_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, max_v<uint16_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, maxl_v<uint16_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingAddTest, Test_32_32) {
+    EXPECT_THAT(saturating_add(min_v<int32_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, max_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, maxl_v<int32_t>), int32_t(zeroll_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zero_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zeror_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zerol_v<int32_t>), int32_t(min_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, max_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, maxl_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zero_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zeror_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zerol_v<int32_t>), int32_t(min_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int32_t>, min_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, minr_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zero_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zeror_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zerol_v<int32_t>), int32_t(maxl_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, min_v<int32_t>), int32_t(zeroll_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, minr_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zero_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zeror_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zerol_v<int32_t>), int32_t(maxll_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, minr_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, maxl_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zeror_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zerol_v<int32_t>), int32_t(zerol_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, min_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, minr_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zero_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zeror_v<int32_t>), int32_t(zerorr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zerol_v<int32_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, max_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, maxl_v<int32_t>), int32_t(maxll_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zero_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zeror_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zerol_v<int32_t>), int32_t(zeroll_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, minr_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, maxl_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, min_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, minr_v<uint32_t>), uint32_t(minrr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, min_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, minr_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, min_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, minr_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingAddTest, Test_32_64) {
+    EXPECT_THAT(saturating_add(min_v<int32_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, max_v<int64_t>), int64_t(min_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int32_t>, maxl_v<int64_t>), int64_t(min_v<int32_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zero_v<int64_t>), int64_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zeror_v<int64_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(min_v<int32_t>, zerol_v<int64_t>), int64_t(min_v<int32_t>) + zerol_v<int64_t>);
+
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, max_v<int64_t>), int64_t(minr_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, maxl_v<int64_t>), int64_t(minr_v<int32_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zero_v<int64_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zeror_v<int64_t>), int64_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_add(minr_v<int32_t>, zerol_v<int64_t>), int64_t(min_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int32_t>, min_v<int64_t>), int64_t(max_v<int32_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int32_t>, minr_v<int64_t>), int64_t(max_v<int32_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int32_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zero_v<int64_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zeror_v<int64_t>), int64_t(max_v<int32_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int32_t>, zerol_v<int64_t>), int64_t(maxl_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, min_v<int64_t>), int64_t(maxl_v<int32_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, minr_v<int64_t>), int64_t(maxl_v<int32_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zero_v<int64_t>), int64_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zeror_v<int64_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int32_t>, zerol_v<int64_t>), int64_t(maxll_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, minr_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, maxl_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zeror_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int32_t>, zerol_v<int64_t>), int64_t(zerol_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, min_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, minr_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zero_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zeror_v<int64_t>), int64_t(zerorr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int32_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, max_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, maxl_v<int64_t>), int64_t(maxll_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zero_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int32_t>, zerol_v<int64_t>), int64_t(zeroll_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, minr_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint32_t>, maxl_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, min_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, minr_v<uint64_t>), uint64_t(minrr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint32_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, min_v<uint64_t>), uint64_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, minr_v<uint64_t>), uint64_t(max_v<uint32_t>) + zeror_v<uint64_t>);
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint32_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, min_v<uint64_t>), uint64_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, minr_v<uint64_t>), uint64_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint32_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingAddTest, Test_64_8) {
+    EXPECT_THAT(saturating_add(min_v<int64_t>, min_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, minr_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, max_v<int8_t>), int64_t(max_v<int8_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int64_t>, maxl_v<int8_t>), int64_t(maxl_v<int8_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zero_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zeror_v<int8_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zerol_v<int8_t>), int64_t(min_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, min_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, minr_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, max_v<int8_t>), int64_t(max_v<int8_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, maxl_v<int8_t>), int64_t(maxl_v<int8_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zero_v<int8_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zeror_v<int8_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zerol_v<int8_t>), int64_t(min_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int64_t>, min_v<int8_t>), int64_t(min_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int64_t>, minr_v<int8_t>), int64_t(minr_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int64_t>, max_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, maxl_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zero_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zeror_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zerol_v<int8_t>), int64_t(maxl_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, min_v<int8_t>), int64_t(min_v<int8_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, minr_v<int8_t>), int64_t(minr_v<int8_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, max_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, maxl_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zero_v<int8_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zeror_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zerol_v<int8_t>), int64_t(maxll_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, min_v<int8_t>), int64_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, minr_v<int8_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, max_v<int8_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, maxl_v<int8_t>), int64_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zero_v<int8_t>), int64_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zeror_v<int8_t>), int64_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zerol_v<int8_t>), int64_t(zerol_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, min_v<int8_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, minr_v<int8_t>), int64_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, max_v<int8_t>), int64_t(max_v<int8_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, maxl_v<int8_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zero_v<int8_t>), int64_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zeror_v<int8_t>), int64_t(zerorr_v<int8_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zerol_v<int8_t>), int64_t(zero_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, min_v<int8_t>), int64_t(min_v<int8_t>) + zerol_v<int64_t>);
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, minr_v<int8_t>), int64_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, max_v<int8_t>), int64_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, maxl_v<int8_t>), int64_t(maxll_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zero_v<int8_t>), int64_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zeror_v<int8_t>), int64_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zerol_v<int8_t>), int64_t(zeroll_v<int8_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, min_v<uint8_t>), uint64_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, minr_v<uint8_t>), uint64_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, max_v<uint8_t>), uint64_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, maxl_v<uint8_t>), uint64_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, min_v<uint8_t>), uint64_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, minr_v<uint8_t>), uint64_t(minrr_v<uint8_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, max_v<uint8_t>), uint64_t(max_v<uint8_t>) + zeror_v<uint64_t>);
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, maxl_v<uint8_t>), uint64_t(max_v<uint8_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, min_v<uint8_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, minr_v<uint8_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, max_v<uint8_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, maxl_v<uint8_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, min_v<uint8_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, minr_v<uint8_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, max_v<uint8_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, maxl_v<uint8_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingAddTest, Test_64_16) {
+    EXPECT_THAT(saturating_add(min_v<int64_t>, min_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, minr_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, max_v<int16_t>), int64_t(max_v<int16_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int64_t>, maxl_v<int16_t>), int64_t(maxl_v<int16_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zero_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zeror_v<int16_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zerol_v<int16_t>), int64_t(min_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, min_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, minr_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, max_v<int16_t>), int64_t(max_v<int16_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, maxl_v<int16_t>), int64_t(maxl_v<int16_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zero_v<int16_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zeror_v<int16_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zerol_v<int16_t>), int64_t(min_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int64_t>, min_v<int16_t>), int64_t(min_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int64_t>, minr_v<int16_t>), int64_t(minr_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int64_t>, max_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, maxl_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zero_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zeror_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zerol_v<int16_t>), int64_t(maxl_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, min_v<int16_t>), int64_t(min_v<int16_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, minr_v<int16_t>), int64_t(minr_v<int16_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, max_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, maxl_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zero_v<int16_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zeror_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zerol_v<int16_t>), int64_t(maxll_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, min_v<int16_t>), int64_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, minr_v<int16_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, max_v<int16_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, maxl_v<int16_t>), int64_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zero_v<int16_t>), int64_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zeror_v<int16_t>), int64_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zerol_v<int16_t>), int64_t(zerol_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, min_v<int16_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, minr_v<int16_t>), int64_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, max_v<int16_t>), int64_t(max_v<int16_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, maxl_v<int16_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zero_v<int16_t>), int64_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zeror_v<int16_t>), int64_t(zerorr_v<int16_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zerol_v<int16_t>), int64_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, min_v<int16_t>), int64_t(min_v<int16_t>) + zerol_v<int64_t>);
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, minr_v<int16_t>), int64_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, max_v<int16_t>), int64_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, maxl_v<int16_t>), int64_t(maxll_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zero_v<int16_t>), int64_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zeror_v<int16_t>), int64_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zerol_v<int16_t>), int64_t(zeroll_v<int16_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, min_v<uint16_t>), uint64_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, minr_v<uint16_t>), uint64_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, max_v<uint16_t>), uint64_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, maxl_v<uint16_t>), uint64_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, min_v<uint16_t>), uint64_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, minr_v<uint16_t>), uint64_t(minrr_v<uint16_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, max_v<uint16_t>), uint64_t(max_v<uint16_t>) + zeror_v<uint64_t>);
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, maxl_v<uint16_t>), uint64_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, min_v<uint16_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, minr_v<uint16_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, max_v<uint16_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, maxl_v<uint16_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, min_v<uint16_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, minr_v<uint16_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, max_v<uint16_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, maxl_v<uint16_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingAddTest, Test_64_32) {
+    EXPECT_THAT(saturating_add(min_v<int64_t>, min_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, minr_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, max_v<int32_t>), int64_t(max_v<int32_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int64_t>, maxl_v<int32_t>), int64_t(maxl_v<int32_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zero_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zeror_v<int32_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zerol_v<int32_t>), int64_t(min_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, min_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, minr_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, max_v<int32_t>), int64_t(max_v<int32_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, maxl_v<int32_t>), int64_t(maxl_v<int32_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zero_v<int32_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zeror_v<int32_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zerol_v<int32_t>), int64_t(min_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int64_t>, min_v<int32_t>), int64_t(min_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int64_t>, minr_v<int32_t>), int64_t(minr_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_add(max_v<int64_t>, max_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, maxl_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zero_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zeror_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zerol_v<int32_t>), int64_t(maxl_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, min_v<int32_t>), int64_t(min_v<int32_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, minr_v<int32_t>), int64_t(minr_v<int32_t>) + maxl_v<int64_t>);
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, max_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, maxl_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zero_v<int32_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zeror_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zerol_v<int32_t>), int64_t(maxll_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, min_v<int32_t>), int64_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, minr_v<int32_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, max_v<int32_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, maxl_v<int32_t>), int64_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zero_v<int32_t>), int64_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zeror_v<int32_t>), int64_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zerol_v<int32_t>), int64_t(zerol_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, min_v<int32_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, minr_v<int32_t>), int64_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, max_v<int32_t>), int64_t(max_v<int32_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, maxl_v<int32_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zero_v<int32_t>), int64_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zeror_v<int32_t>), int64_t(zerorr_v<int32_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zerol_v<int32_t>), int64_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, min_v<int32_t>), int64_t(min_v<int32_t>) + zerol_v<int64_t>);
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, minr_v<int32_t>), int64_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, max_v<int32_t>), int64_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, maxl_v<int32_t>), int64_t(maxll_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zero_v<int32_t>), int64_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zeror_v<int32_t>), int64_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zerol_v<int32_t>), int64_t(zeroll_v<int32_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, min_v<uint32_t>), uint64_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, minr_v<uint32_t>), uint64_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, max_v<uint32_t>), uint64_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, maxl_v<uint32_t>), uint64_t(maxl_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, min_v<uint32_t>), uint64_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, minr_v<uint32_t>), uint64_t(minrr_v<uint32_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, max_v<uint32_t>), uint64_t(max_v<uint32_t>) + zeror_v<uint64_t>);
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, maxl_v<uint32_t>), uint64_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, min_v<uint32_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, minr_v<uint32_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, max_v<uint32_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, maxl_v<uint32_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, min_v<uint32_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, minr_v<uint32_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, max_v<uint32_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, maxl_v<uint32_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingAddTest, Test_64_64) {
+    EXPECT_THAT(saturating_add(min_v<int64_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, max_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, maxl_v<int64_t>), int64_t(zeroll_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zero_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zeror_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(min_v<int64_t>, zerol_v<int64_t>), int64_t(min_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, max_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, maxl_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zero_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zeror_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_add(minr_v<int64_t>, zerol_v<int64_t>), int64_t(min_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(max_v<int64_t>, min_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, minr_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zero_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zeror_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(max_v<int64_t>, zerol_v<int64_t>), int64_t(maxl_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, min_v<int64_t>), int64_t(zeroll_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, minr_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zero_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zeror_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<int64_t>, zerol_v<int64_t>), int64_t(maxll_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, minr_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, maxl_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zeror_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_add(zero_v<int64_t>, zerol_v<int64_t>), int64_t(zerol_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, min_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, minr_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zero_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zeror_v<int64_t>), int64_t(zerorr_v<int64_t>));
+    EXPECT_THAT(saturating_add(zeror_v<int64_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, max_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, maxl_v<int64_t>), int64_t(maxll_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zero_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_add(zerol_v<int64_t>, zerol_v<int64_t>), int64_t(zeroll_v<int64_t>));
+
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, minr_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(min_v<uint64_t>, maxl_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, min_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, minr_v<uint64_t>), uint64_t(minrr_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(minr_v<uint64_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, min_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, minr_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(max_v<uint64_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, min_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, minr_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_add(maxl_v<uint64_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingSubTest, Test_8_8) {
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, min_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, minr_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, max_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, maxl_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zero_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zeror_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zerol_v<int8_t>), int8_t(minr_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, min_v<int8_t>), int8_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, minr_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, max_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, maxl_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zero_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zeror_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zerol_v<int8_t>), int8_t(minrr_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, min_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, minr_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, max_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, maxl_v<int8_t>), int8_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zero_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zeror_v<int8_t>), int8_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zerol_v<int8_t>), int8_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, min_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, minr_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, max_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, maxl_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zero_v<int8_t>), int8_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zeror_v<int8_t>), int8_t(maxll_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zerol_v<int8_t>), int8_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, min_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, minr_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, max_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, maxl_v<int8_t>), int8_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zero_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zeror_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zerol_v<int8_t>), int8_t(zeror_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, min_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, minr_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, max_v<int8_t>), int8_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, maxl_v<int8_t>), int8_t(minrr_v<int8_t>) + zeror_v<int16_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zero_v<int8_t>), int8_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zeror_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zerol_v<int8_t>), int8_t(zerorr_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, min_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, minr_v<int8_t>), int8_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, max_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, maxl_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zero_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zeror_v<int8_t>), int8_t(zeroll_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zerol_v<int8_t>), int8_t(zero_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, min_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, minr_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, max_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, maxl_v<uint8_t>), uint8_t(min_v<uint8_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, min_v<uint8_t>), uint8_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, minr_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, max_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, maxl_v<uint8_t>), uint8_t(min_v<uint8_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, min_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, minr_v<uint8_t>), uint8_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, max_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, maxl_v<uint8_t>), uint8_t(minr_v<uint8_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, min_v<uint8_t>), uint8_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, minr_v<uint8_t>), uint8_t(maxll_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, max_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, maxl_v<uint8_t>), uint8_t(min_v<uint8_t>));
+}
+
+TEST(SaturatingSubTest, Test_8_16) {
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, min_v<int16_t>), int16_t(minr_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, minr_v<int16_t>), int16_t(min_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, maxl_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zero_v<int16_t>), int16_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zeror_v<int16_t>), int16_t(min_v<int8_t>) - zeror_v<int16_t>);
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zerol_v<int16_t>), int16_t(minr_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, min_v<int16_t>), int16_t(minrr_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, minr_v<int16_t>), int16_t(minr_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, maxl_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zero_v<int16_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zeror_v<int16_t>), int16_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zerol_v<int16_t>), int16_t(minrr_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, max_v<int16_t>), int16_t(max_v<int8_t>) + minr_v<int16_t>);
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, maxl_v<int16_t>), int16_t(max_v<int8_t>) + minrr_v<int16_t>);
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zero_v<int16_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zeror_v<int16_t>), int16_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zerol_v<int16_t>), int16_t(max_v<int8_t>) + zeror_v<int16_t>);
+
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, max_v<int16_t>), int16_t(max_v<int8_t>) + min_v<int16_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, maxl_v<int16_t>), int16_t(max_v<int8_t>) + minr_v<int16_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zero_v<int16_t>), int16_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zeror_v<int16_t>), int16_t(maxll_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zerol_v<int16_t>), int16_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, max_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, maxl_v<int16_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zeror_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zerol_v<int16_t>), int16_t(zeror_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, max_v<int16_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, maxl_v<int16_t>), int16_t(minrr_v<int16_t>) + zeror_v<int16_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zero_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zeror_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zerol_v<int16_t>), int16_t(zerorr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, minr_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, maxl_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zero_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zeror_v<int16_t>), int16_t(zeroll_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zerol_v<int16_t>), int16_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, minr_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, maxl_v<uint16_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, min_v<uint16_t>), uint16_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, minr_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, maxl_v<uint16_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, min_v<uint16_t>), uint16_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, minr_v<uint16_t>), uint16_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, maxl_v<uint16_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, min_v<uint16_t>), uint16_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, minr_v<uint16_t>), uint16_t(maxll_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, maxl_v<uint16_t>), uint16_t(min_v<uint16_t>));
+}
+
+TEST(SaturatingSubTest, Test_8_32) {
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, min_v<int32_t>), int32_t(minr_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, minr_v<int32_t>), int32_t(min_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zero_v<int32_t>), int32_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zeror_v<int32_t>), int32_t(min_v<int8_t>) - zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zerol_v<int32_t>), int32_t(minr_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, min_v<int32_t>), int32_t(minrr_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, minr_v<int32_t>), int32_t(minr_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zero_v<int32_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zeror_v<int32_t>), int32_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zerol_v<int32_t>), int32_t(minrr_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, max_v<int32_t>), int32_t(max_v<int8_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, maxl_v<int32_t>), int32_t(max_v<int8_t>) + minrr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zero_v<int32_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zeror_v<int32_t>), int32_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zerol_v<int32_t>), int32_t(max_v<int8_t>) + zeror_v<int32_t>);
+
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, max_v<int32_t>), int32_t(max_v<int8_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, maxl_v<int32_t>), int32_t(max_v<int8_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zero_v<int32_t>), int32_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zeror_v<int32_t>), int32_t(maxll_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zerol_v<int32_t>), int32_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, max_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, maxl_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zeror_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zerol_v<int32_t>), int32_t(zeror_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, max_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, maxl_v<int32_t>), int32_t(minrr_v<int32_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zero_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zeror_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zerol_v<int32_t>), int32_t(zerorr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, minr_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, maxl_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zero_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zeror_v<int32_t>), int32_t(zeroll_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zerol_v<int32_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, minr_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, min_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, minr_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, min_v<uint32_t>), uint32_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, minr_v<uint32_t>), uint32_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, min_v<uint32_t>), uint32_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, minr_v<uint32_t>), uint32_t(maxll_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+}
+
+TEST(SaturatingSubTest, Test_8_64) {
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, min_v<int64_t>), int64_t(minr_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, minr_v<int64_t>), int64_t(min_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zero_v<int64_t>), int64_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zeror_v<int64_t>), int64_t(min_v<int8_t>) - zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int8_t>, zerol_v<int64_t>), int64_t(minr_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, min_v<int64_t>), int64_t(minrr_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, minr_v<int64_t>), int64_t(minr_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zero_v<int64_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zeror_v<int64_t>), int64_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int8_t>, zerol_v<int64_t>), int64_t(minrr_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, max_v<int64_t>), int64_t(max_v<int8_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, maxl_v<int64_t>), int64_t(max_v<int8_t>) + minrr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zero_v<int64_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zeror_v<int64_t>), int64_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(max_v<int8_t>, zerol_v<int64_t>), int64_t(max_v<int8_t>) + zeror_v<int64_t>);
+
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, max_v<int64_t>), int64_t(max_v<int8_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, maxl_v<int64_t>), int64_t(max_v<int8_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zero_v<int64_t>), int64_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zeror_v<int64_t>), int64_t(maxll_v<int8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int8_t>, zerol_v<int64_t>), int64_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, max_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zeror_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int8_t>, zerol_v<int64_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, max_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zero_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int8_t>, zerol_v<int64_t>), int64_t(zerorr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, minr_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, maxl_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zero_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zeror_v<int64_t>), int64_t(zeroll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int8_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint8_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, min_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint8_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, min_v<uint64_t>), uint64_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, minr_v<uint64_t>), uint64_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint8_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, min_v<uint64_t>), uint64_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, minr_v<uint64_t>), uint64_t(maxll_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint8_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+}
+
+TEST(SaturatingSubTest, Test_16_8) {
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, min_v<int8_t>), int16_t(max_v<int8_t>) + minr_v<int16_t>);
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, minr_v<int8_t>), int16_t(max_v<int8_t>) + min_v<int16_t>);
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, max_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, maxl_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zero_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zeror_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zerol_v<int8_t>), int16_t(minr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, min_v<int8_t>), int16_t(max_v<int8_t>) + minrr_v<int16_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, minr_v<int8_t>), int16_t(max_v<int8_t>) + minr_v<int16_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, max_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, maxl_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zero_v<int8_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zeror_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zerol_v<int8_t>), int16_t(minrr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, min_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, minr_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, max_v<int8_t>), int16_t(minr_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, maxl_v<int8_t>), int16_t(minrr_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zero_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zeror_v<int8_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zerol_v<int8_t>), int16_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, min_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, minr_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, max_v<int8_t>), int16_t(min_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, maxl_v<int8_t>), int16_t(minr_v<int8_t>) + max_v<int16_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zero_v<int8_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zeror_v<int8_t>), int16_t(maxll_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zerol_v<int8_t>), int16_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, min_v<int8_t>), int16_t(max_v<int8_t>) + zeror_v<int16_t>);
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, minr_v<int8_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, max_v<int8_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, maxl_v<int8_t>), int16_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zero_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zeror_v<int8_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zerol_v<int8_t>), int16_t(zeror_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, min_v<int8_t>), int16_t(max_v<int8_t>) + zerorr_v<int16_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, minr_v<int8_t>), int16_t(max_v<int8_t>) + zeror_v<int16_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, max_v<int8_t>), int16_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, maxl_v<int8_t>), int16_t(minrr_v<int8_t>) + zeror_v<int16_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zero_v<int8_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zeror_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zerol_v<int8_t>), int16_t(zerorr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, min_v<int8_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, minr_v<int8_t>), int16_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, max_v<int8_t>), int16_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, maxl_v<int8_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zero_v<int8_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zeror_v<int8_t>), int16_t(zeroll_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zerol_v<int8_t>), int16_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, min_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, minr_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, max_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, maxl_v<uint8_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, min_v<uint8_t>), uint16_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, minr_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, max_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, maxl_v<uint8_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, min_v<uint8_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, minr_v<uint8_t>), uint16_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, max_v<uint8_t>), max_v<uint16_t> - uint16_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, maxl_v<uint8_t>), max_v<uint16_t> - uint16_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, min_v<uint8_t>), uint16_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, minr_v<uint8_t>), uint16_t(maxll_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, max_v<uint8_t>), maxl_v<uint16_t> - uint16_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, maxl_v<uint8_t>), max_v<uint16_t> - uint16_t(max_v<uint8_t>));
+}
+
+TEST(SaturatingSubTest, Test_16_16) {
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, min_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, minr_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, maxl_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zero_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zeror_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zerol_v<int16_t>), int16_t(minr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, min_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, minr_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, maxl_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zero_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zeror_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zerol_v<int16_t>), int16_t(minrr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, max_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, maxl_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zero_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zeror_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zerol_v<int16_t>), int16_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, max_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, maxl_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zero_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zeror_v<int16_t>), int16_t(maxll_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zerol_v<int16_t>), int16_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, max_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, maxl_v<int16_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zeror_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zerol_v<int16_t>), int16_t(zeror_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, max_v<int16_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, maxl_v<int16_t>), int16_t(minrr_v<int16_t>) + zeror_v<int16_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zero_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zeror_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zerol_v<int16_t>), int16_t(zerorr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, minr_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, maxl_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zero_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zeror_v<int16_t>), int16_t(zeroll_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zerol_v<int16_t>), int16_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, minr_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, maxl_v<uint16_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, min_v<uint16_t>), uint16_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, minr_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, maxl_v<uint16_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, min_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, minr_v<uint16_t>), uint16_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, maxl_v<uint16_t>), uint16_t(minr_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, min_v<uint16_t>), uint16_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, minr_v<uint16_t>), uint16_t(maxll_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, maxl_v<uint16_t>), uint16_t(min_v<uint16_t>));
+}
+
+TEST(SaturatingSubTest, Test_16_32) {
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, min_v<int32_t>), int32_t(minr_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, minr_v<int32_t>), int32_t(min_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zero_v<int32_t>), int32_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zeror_v<int32_t>), int32_t(min_v<int16_t>) - zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zerol_v<int32_t>), int32_t(minr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, min_v<int32_t>), int32_t(minrr_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, minr_v<int32_t>), int32_t(minr_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zero_v<int32_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zeror_v<int32_t>), int32_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zerol_v<int32_t>), int32_t(minrr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, max_v<int32_t>), int32_t(max_v<int16_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, maxl_v<int32_t>), int32_t(max_v<int16_t>) + minrr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zero_v<int32_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zeror_v<int32_t>), int32_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zerol_v<int32_t>), int32_t(max_v<int16_t>) + zeror_v<int32_t>);
+
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, max_v<int32_t>), int32_t(max_v<int16_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, maxl_v<int32_t>), int32_t(max_v<int16_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zero_v<int32_t>), int32_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zeror_v<int32_t>), int32_t(maxll_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zerol_v<int32_t>), int32_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, max_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, maxl_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zeror_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zerol_v<int32_t>), int32_t(zeror_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, max_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, maxl_v<int32_t>), int32_t(minrr_v<int32_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zero_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zeror_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zerol_v<int32_t>), int32_t(zerorr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, minr_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, maxl_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zero_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zeror_v<int32_t>), int32_t(zeroll_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zerol_v<int32_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, minr_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, min_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, minr_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, min_v<uint32_t>), uint32_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, minr_v<uint32_t>), uint32_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, min_v<uint32_t>), uint32_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, minr_v<uint32_t>), uint32_t(maxll_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+}
+
+TEST(SaturatingSubTest, Test_16_64) {
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, min_v<int64_t>), int64_t(minr_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, minr_v<int64_t>), int64_t(min_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zero_v<int64_t>), int64_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zeror_v<int64_t>), int64_t(min_v<int16_t>) - zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int16_t>, zerol_v<int64_t>), int64_t(minr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, min_v<int64_t>), int64_t(minrr_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, minr_v<int64_t>), int64_t(minr_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zero_v<int64_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zeror_v<int64_t>), int64_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int16_t>, zerol_v<int64_t>), int64_t(minrr_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, max_v<int64_t>), int64_t(max_v<int16_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, maxl_v<int64_t>), int64_t(max_v<int16_t>) + minrr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zero_v<int64_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zeror_v<int64_t>), int64_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(max_v<int16_t>, zerol_v<int64_t>), int64_t(max_v<int16_t>) + zeror_v<int64_t>);
+
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, max_v<int64_t>), int64_t(max_v<int16_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, maxl_v<int64_t>), int64_t(max_v<int16_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zero_v<int64_t>), int64_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zeror_v<int64_t>), int64_t(maxll_v<int16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int16_t>, zerol_v<int64_t>), int64_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, max_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zeror_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int16_t>, zerol_v<int64_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, max_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zero_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int16_t>, zerol_v<int64_t>), int64_t(zerorr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, minr_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, maxl_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zero_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zeror_v<int64_t>), int64_t(zeroll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int16_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint16_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, min_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint16_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, min_v<uint64_t>), uint64_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, minr_v<uint64_t>), uint64_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint16_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, min_v<uint64_t>), uint64_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, minr_v<uint64_t>), uint64_t(maxll_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint16_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+}
+
+TEST(SaturatingSubTest, Test_32_8) {
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, min_v<int8_t>), int32_t(max_v<int8_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, minr_v<int8_t>), int32_t(max_v<int8_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, max_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, maxl_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zero_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zeror_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zerol_v<int8_t>), int32_t(minr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, min_v<int8_t>), int32_t(max_v<int8_t>) + minrr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, minr_v<int8_t>), int32_t(max_v<int8_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, max_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, maxl_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zero_v<int8_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zeror_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zerol_v<int8_t>), int32_t(minrr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, min_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, minr_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, max_v<int8_t>), int32_t(minr_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, maxl_v<int8_t>), int32_t(minrr_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zero_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zeror_v<int8_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zerol_v<int8_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, min_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, minr_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, max_v<int8_t>), int32_t(min_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, maxl_v<int8_t>), int32_t(minr_v<int8_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zero_v<int8_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zeror_v<int8_t>), int32_t(maxll_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zerol_v<int8_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, min_v<int8_t>), int32_t(max_v<int8_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, minr_v<int8_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, max_v<int8_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, maxl_v<int8_t>), int32_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zero_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zeror_v<int8_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zerol_v<int8_t>), int32_t(zeror_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, min_v<int8_t>), int32_t(max_v<int8_t>) + zerorr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, minr_v<int8_t>), int32_t(max_v<int8_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, max_v<int8_t>), int32_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, maxl_v<int8_t>), int32_t(minrr_v<int8_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zero_v<int8_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zeror_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zerol_v<int8_t>), int32_t(zerorr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, min_v<int8_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, minr_v<int8_t>), int32_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, max_v<int8_t>), int32_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, maxl_v<int8_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zero_v<int8_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zeror_v<int8_t>), int32_t(zeroll_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zerol_v<int8_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, min_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, minr_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, max_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, maxl_v<uint8_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, min_v<uint8_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, minr_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, max_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, maxl_v<uint8_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, min_v<uint8_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, minr_v<uint8_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, max_v<uint8_t>), max_v<uint32_t> - uint32_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, maxl_v<uint8_t>), max_v<uint32_t> - uint32_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, min_v<uint8_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, minr_v<uint8_t>), uint32_t(maxll_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, max_v<uint8_t>), maxl_v<uint32_t> - uint32_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, maxl_v<uint8_t>), max_v<uint32_t> - uint32_t(max_v<uint8_t>));
+}
+
+TEST(SaturatingSubTest, Test_32_16) {
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, min_v<int16_t>), int32_t(max_v<int16_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, minr_v<int16_t>), int32_t(max_v<int16_t>) + min_v<int32_t>);
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, max_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, maxl_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zero_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zeror_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zerol_v<int16_t>), int32_t(minr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, min_v<int16_t>), int32_t(max_v<int16_t>) + minrr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, minr_v<int16_t>), int32_t(max_v<int16_t>) + minr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, max_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, maxl_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zero_v<int16_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zeror_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zerol_v<int16_t>), int32_t(minrr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, min_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, minr_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, max_v<int16_t>), int32_t(minr_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, maxl_v<int16_t>), int32_t(minrr_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zero_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zeror_v<int16_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zerol_v<int16_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, min_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, minr_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, max_v<int16_t>), int32_t(min_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, maxl_v<int16_t>), int32_t(minr_v<int16_t>) + max_v<int32_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zero_v<int16_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zeror_v<int16_t>), int32_t(maxll_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zerol_v<int16_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, min_v<int16_t>), int32_t(max_v<int16_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, minr_v<int16_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, max_v<int16_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, maxl_v<int16_t>), int32_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zero_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zeror_v<int16_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zerol_v<int16_t>), int32_t(zeror_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, min_v<int16_t>), int32_t(max_v<int16_t>) + zerorr_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, minr_v<int16_t>), int32_t(max_v<int16_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, max_v<int16_t>), int32_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, maxl_v<int16_t>), int32_t(minrr_v<int16_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zero_v<int16_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zeror_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zerol_v<int16_t>), int32_t(zerorr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, min_v<int16_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, minr_v<int16_t>), int32_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, max_v<int16_t>), int32_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, maxl_v<int16_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zero_v<int16_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zeror_v<int16_t>), int32_t(zeroll_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zerol_v<int16_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, min_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, minr_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, max_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, maxl_v<uint16_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, min_v<uint16_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, minr_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, max_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, maxl_v<uint16_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, min_v<uint16_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, minr_v<uint16_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, max_v<uint16_t>), max_v<uint32_t> - uint32_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, maxl_v<uint16_t>), max_v<uint32_t> - uint32_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, min_v<uint16_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, minr_v<uint16_t>), uint32_t(maxll_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, max_v<uint16_t>), maxl_v<uint32_t> - uint32_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, maxl_v<uint16_t>), max_v<uint32_t> - uint32_t(max_v<uint16_t>));
+}
+
+TEST(SaturatingSubTest, Test_32_32) {
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, min_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, minr_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zero_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zeror_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zerol_v<int32_t>), int32_t(minr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, min_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, minr_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zero_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zeror_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zerol_v<int32_t>), int32_t(minrr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, max_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, maxl_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zero_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zeror_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zerol_v<int32_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, max_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, maxl_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zero_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zeror_v<int32_t>), int32_t(maxll_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zerol_v<int32_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, max_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, maxl_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zeror_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zerol_v<int32_t>), int32_t(zeror_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, max_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, maxl_v<int32_t>), int32_t(minrr_v<int32_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zero_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zeror_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zerol_v<int32_t>), int32_t(zerorr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, minr_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, maxl_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zero_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zeror_v<int32_t>), int32_t(zeroll_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zerol_v<int32_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, minr_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, min_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, minr_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, min_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, minr_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, maxl_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, min_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, minr_v<uint32_t>), uint32_t(maxll_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+}
+
+TEST(SaturatingSubTest, Test_32_64) {
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, min_v<int64_t>), int64_t(minr_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, minr_v<int64_t>), int64_t(min_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zero_v<int64_t>), int64_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zeror_v<int64_t>), int64_t(min_v<int32_t>) - zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int32_t>, zerol_v<int64_t>), int64_t(minr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, min_v<int64_t>), int64_t(minrr_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, minr_v<int64_t>), int64_t(minr_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zero_v<int64_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zeror_v<int64_t>), int64_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int32_t>, zerol_v<int64_t>), int64_t(minrr_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, max_v<int64_t>), int64_t(max_v<int32_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, maxl_v<int64_t>), int64_t(max_v<int32_t>) + minrr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zero_v<int64_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zeror_v<int64_t>), int64_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(max_v<int32_t>, zerol_v<int64_t>), int64_t(max_v<int32_t>) + zeror_v<int64_t>);
+
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, max_v<int64_t>), int64_t(max_v<int32_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, maxl_v<int64_t>), int64_t(max_v<int32_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zero_v<int64_t>), int64_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zeror_v<int64_t>), int64_t(maxll_v<int32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int32_t>, zerol_v<int64_t>), int64_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, max_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zeror_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int32_t>, zerol_v<int64_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, max_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zero_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int32_t>, zerol_v<int64_t>), int64_t(zerorr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, minr_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, maxl_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zero_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zeror_v<int64_t>), int64_t(zeroll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int32_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint32_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, min_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint32_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, min_v<uint64_t>), uint64_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, minr_v<uint64_t>), uint64_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint32_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, min_v<uint64_t>), uint64_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, minr_v<uint64_t>), uint64_t(maxll_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint32_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+}
+
+TEST(SaturatingSubTest, Test_64_8) {
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, min_v<int8_t>), int64_t(max_v<int8_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, minr_v<int8_t>), int64_t(max_v<int8_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, max_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, maxl_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zero_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zeror_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zerol_v<int8_t>), int64_t(minr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, min_v<int8_t>), int64_t(max_v<int8_t>) + minrr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, minr_v<int8_t>), int64_t(max_v<int8_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, max_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, maxl_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zero_v<int8_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zeror_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zerol_v<int8_t>), int64_t(minrr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, min_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, minr_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, max_v<int8_t>), int64_t(minr_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, maxl_v<int8_t>), int64_t(minrr_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zero_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zeror_v<int8_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zerol_v<int8_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, min_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, minr_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, max_v<int8_t>), int64_t(min_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, maxl_v<int8_t>), int64_t(minr_v<int8_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zero_v<int8_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zeror_v<int8_t>), int64_t(maxll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zerol_v<int8_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, min_v<int8_t>), int64_t(max_v<int8_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, minr_v<int8_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, max_v<int8_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, maxl_v<int8_t>), int64_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zero_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zeror_v<int8_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zerol_v<int8_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, min_v<int8_t>), int64_t(max_v<int8_t>) + zerorr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, minr_v<int8_t>), int64_t(max_v<int8_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, max_v<int8_t>), int64_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, maxl_v<int8_t>), int64_t(minrr_v<int8_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zero_v<int8_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zeror_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zerol_v<int8_t>), int64_t(zerorr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, min_v<int8_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, minr_v<int8_t>), int64_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, max_v<int8_t>), int64_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, maxl_v<int8_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zero_v<int8_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zeror_v<int8_t>), int64_t(zeroll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zerol_v<int8_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, min_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, minr_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, max_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, maxl_v<uint8_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, min_v<uint8_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, minr_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, max_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, maxl_v<uint8_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, min_v<uint8_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, minr_v<uint8_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, max_v<uint8_t>), max_v<uint64_t> - uint64_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, maxl_v<uint8_t>), max_v<uint64_t> - uint64_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, min_v<uint8_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, minr_v<uint8_t>), uint64_t(maxll_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, max_v<uint8_t>), maxl_v<uint64_t> - uint64_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, maxl_v<uint8_t>), max_v<uint64_t> - uint64_t(max_v<uint8_t>));
+}
+
+TEST(SaturatingSubTest, Test_64_16) {
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, min_v<int16_t>), int64_t(max_v<int16_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, minr_v<int16_t>), int64_t(max_v<int16_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, max_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, maxl_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zero_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zeror_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zerol_v<int16_t>), int64_t(minr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, min_v<int16_t>), int64_t(max_v<int16_t>) + minrr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, minr_v<int16_t>), int64_t(max_v<int16_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, max_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, maxl_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zero_v<int16_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zeror_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zerol_v<int16_t>), int64_t(minrr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, min_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, minr_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, max_v<int16_t>), int64_t(minr_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, maxl_v<int16_t>), int64_t(minrr_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zero_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zeror_v<int16_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zerol_v<int16_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, min_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, minr_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, max_v<int16_t>), int64_t(min_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, maxl_v<int16_t>), int64_t(minr_v<int16_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zero_v<int16_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zeror_v<int16_t>), int64_t(maxll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zerol_v<int16_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, min_v<int16_t>), int64_t(max_v<int16_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, minr_v<int16_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, max_v<int16_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, maxl_v<int16_t>), int64_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zero_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zeror_v<int16_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zerol_v<int16_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, min_v<int16_t>), int64_t(max_v<int16_t>) + zerorr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, minr_v<int16_t>), int64_t(max_v<int16_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, max_v<int16_t>), int64_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, maxl_v<int16_t>), int64_t(minrr_v<int16_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zero_v<int16_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zeror_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zerol_v<int16_t>), int64_t(zerorr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, min_v<int16_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, minr_v<int16_t>), int64_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, max_v<int16_t>), int64_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, maxl_v<int16_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zero_v<int16_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zeror_v<int16_t>), int64_t(zeroll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zerol_v<int16_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, min_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, minr_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, max_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, maxl_v<uint16_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, min_v<uint16_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, minr_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, max_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, maxl_v<uint16_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, min_v<uint16_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, minr_v<uint16_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, max_v<uint16_t>), max_v<uint64_t> - uint64_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, maxl_v<uint16_t>), max_v<uint64_t> - uint64_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, min_v<uint16_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, minr_v<uint16_t>), uint64_t(maxll_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, max_v<uint16_t>), maxl_v<uint64_t> - uint64_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, maxl_v<uint16_t>), max_v<uint64_t> - uint64_t(max_v<uint16_t>));
+}
+
+TEST(SaturatingSubTest, Test_64_32) {
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, min_v<int32_t>), int64_t(max_v<int32_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, minr_v<int32_t>), int64_t(max_v<int32_t>) + min_v<int64_t>);
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, max_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, maxl_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zero_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zeror_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zerol_v<int32_t>), int64_t(minr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, min_v<int32_t>), int64_t(max_v<int32_t>) + minrr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, minr_v<int32_t>), int64_t(max_v<int32_t>) + minr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, max_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, maxl_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zero_v<int32_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zeror_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zerol_v<int32_t>), int64_t(minrr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, min_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, minr_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, max_v<int32_t>), int64_t(minr_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, maxl_v<int32_t>), int64_t(minrr_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zero_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zeror_v<int32_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zerol_v<int32_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, min_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, minr_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, max_v<int32_t>), int64_t(min_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, maxl_v<int32_t>), int64_t(minr_v<int32_t>) + max_v<int64_t>);
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zero_v<int32_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zeror_v<int32_t>), int64_t(maxll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zerol_v<int32_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, min_v<int32_t>), int64_t(max_v<int32_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, minr_v<int32_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, max_v<int32_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, maxl_v<int32_t>), int64_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zero_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zeror_v<int32_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zerol_v<int32_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, min_v<int32_t>), int64_t(max_v<int32_t>) + zerorr_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, minr_v<int32_t>), int64_t(max_v<int32_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, max_v<int32_t>), int64_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, maxl_v<int32_t>), int64_t(minrr_v<int32_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zero_v<int32_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zeror_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zerol_v<int32_t>), int64_t(zerorr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, min_v<int32_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, minr_v<int32_t>), int64_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, max_v<int32_t>), int64_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, maxl_v<int32_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zero_v<int32_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zeror_v<int32_t>), int64_t(zeroll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zerol_v<int32_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, min_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, minr_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, max_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, maxl_v<uint32_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, min_v<uint32_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, minr_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, max_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, maxl_v<uint32_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, min_v<uint32_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, minr_v<uint32_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, max_v<uint32_t>), max_v<uint64_t> - uint64_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, maxl_v<uint32_t>), max_v<uint64_t> - uint64_t(maxl_v<uint32_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, min_v<uint32_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, minr_v<uint32_t>), uint64_t(maxll_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, max_v<uint32_t>), maxl_v<uint64_t> - uint64_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, maxl_v<uint32_t>), max_v<uint64_t> - uint64_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingSubTest, Test_64_64) {
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, min_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, minr_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zero_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zeror_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(min_v<int64_t>, zerol_v<int64_t>), int64_t(minr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, min_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, minr_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zero_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zeror_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<int64_t>, zerol_v<int64_t>), int64_t(minrr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, max_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, maxl_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zero_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zeror_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(max_v<int64_t>, zerol_v<int64_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, max_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, maxl_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zero_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zeror_v<int64_t>), int64_t(maxll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<int64_t>, zerol_v<int64_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, max_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zeror_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zero_v<int64_t>, zerol_v<int64_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, max_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zero_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zeror_v<int64_t>, zerol_v<int64_t>), int64_t(zerorr_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, minr_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, maxl_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zero_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zeror_v<int64_t>), int64_t(zeroll_v<int64_t>));
+    EXPECT_THAT(saturating_sub(zerol_v<int64_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(min_v<uint64_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, min_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(minr_v<uint64_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, min_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, minr_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(max_v<uint64_t>, maxl_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, min_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, minr_v<uint64_t>), uint64_t(maxll_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_sub(maxl_v<uint64_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+}
+
+TEST(SaturatingMulTest, Test_8_8) {
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, min_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, minr_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, max_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, maxl_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zero_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zeror_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zerol_v<int8_t>), int8_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, min_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, minr_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, max_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, maxl_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zero_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zeror_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zerol_v<int8_t>), int8_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, min_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, minr_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, max_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, maxl_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zero_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zeror_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zerol_v<int8_t>), int8_t(minr_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, min_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, minr_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, max_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, maxl_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zero_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zeror_v<int8_t>), int8_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zerol_v<int8_t>), int8_t(minrr_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, min_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, minr_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, max_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, maxl_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zero_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zeror_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zerol_v<int8_t>), int8_t(zero_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, min_v<int8_t>), int8_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, minr_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, max_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, maxl_v<int8_t>), int8_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zero_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zeror_v<int8_t>), int8_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zerol_v<int8_t>), int8_t(zerol_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, min_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, minr_v<int8_t>), int8_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, max_v<int8_t>), int8_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, maxl_v<int8_t>), int8_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zero_v<int8_t>), int8_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zeror_v<int8_t>), int8_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zerol_v<int8_t>), int8_t(zeror_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, min_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, minr_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, max_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, maxl_v<uint8_t>), uint8_t(min_v<uint8_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, min_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, minr_v<uint8_t>), uint8_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, max_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, maxl_v<uint8_t>), uint8_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, min_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, minr_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, max_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, maxl_v<uint8_t>), uint8_t(max_v<uint8_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, min_v<uint8_t>), uint8_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, minr_v<uint8_t>), uint8_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, max_v<uint8_t>), uint8_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, maxl_v<uint8_t>), uint8_t(max_v<uint8_t>));
+}
+
+TEST(SaturatingMulTest, Test_8_16) {
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, maxl_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zeror_v<int16_t>), int16_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zerol_v<int16_t>), int16_t(max_v<int8_t>) + zeror_v<int16_t>);
+
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, maxl_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zeror_v<int16_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zerol_v<int16_t>), int16_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zeror_v<int16_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zerol_v<int16_t>), int16_t(minr_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zeror_v<int16_t>), int16_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zerol_v<int16_t>), int16_t(minrr_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, min_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, minr_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, max_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, maxl_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zeror_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zerol_v<int16_t>), int16_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, minr_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, maxl_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zeror_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zerol_v<int16_t>), int16_t(zerol_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, max_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, maxl_v<int16_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zeror_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zerol_v<int16_t>), int16_t(zeror_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, minr_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, maxl_v<uint16_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, minr_v<uint16_t>), uint16_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, maxl_v<uint16_t>), uint16_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, minr_v<uint16_t>), uint16_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, minr_v<uint16_t>), uint16_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+}
+
+TEST(SaturatingMulTest, Test_8_32) {
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zeror_v<int32_t>), int32_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zerol_v<int32_t>), int32_t(max_v<int8_t>) + zeror_v<int32_t>);
+
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zeror_v<int32_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zerol_v<int32_t>), int32_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zeror_v<int32_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zerol_v<int32_t>), int32_t(minr_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zeror_v<int32_t>), int32_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zerol_v<int32_t>), int32_t(minrr_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, min_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, minr_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, max_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, maxl_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zeror_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zerol_v<int32_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, minr_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, maxl_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zeror_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zerol_v<int32_t>), int32_t(zerol_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, max_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, maxl_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zeror_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zerol_v<int32_t>), int32_t(zeror_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, minr_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, minr_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, maxl_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, minr_v<uint32_t>), uint32_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, minr_v<uint32_t>), uint32_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingMulTest, Test_8_64) {
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zeror_v<int64_t>), int64_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(min_v<int8_t>, zerol_v<int64_t>), int64_t(max_v<int8_t>) + zeror_v<int64_t>);
+
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zeror_v<int64_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int8_t>, zerol_v<int64_t>), int64_t(max_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zeror_v<int64_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(max_v<int8_t>, zerol_v<int64_t>), int64_t(minr_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zeror_v<int64_t>), int64_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int8_t>, zerol_v<int64_t>), int64_t(minrr_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, min_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, minr_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, max_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, maxl_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int8_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, minr_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, maxl_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zeror_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int8_t>, zerol_v<int64_t>), int64_t(zerol_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, max_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zeror_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int8_t>, zerol_v<int64_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint8_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, minr_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint8_t>, maxl_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, minr_v<uint64_t>), uint64_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint8_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, minr_v<uint64_t>), uint64_t(maxl_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint8_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingMulTest, Test_16_8) {
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, min_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, minr_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, max_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, maxl_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zero_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zeror_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zerol_v<int8_t>), int16_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, min_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, minr_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, max_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, maxl_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zero_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zeror_v<int8_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zerol_v<int8_t>), int16_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, min_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, minr_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, max_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, maxl_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zero_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zeror_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zerol_v<int8_t>), int16_t(minr_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, min_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, minr_v<int8_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, max_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, maxl_v<int8_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zero_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zeror_v<int8_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zerol_v<int8_t>), int16_t(minrr_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, min_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, minr_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, max_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, maxl_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zero_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zeror_v<int8_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zerol_v<int8_t>), int16_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, min_v<int8_t>), int16_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, minr_v<int8_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, max_v<int8_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, maxl_v<int8_t>), int16_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zero_v<int8_t>), int16_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zeror_v<int8_t>), int16_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zerol_v<int8_t>), int16_t(zerol_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, min_v<int8_t>), int16_t(max_v<int8_t>) + zeror_v<int16_t>);
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, minr_v<int8_t>), int16_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, max_v<int8_t>), int16_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, maxl_v<int8_t>), int16_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zero_v<int8_t>), int16_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zeror_v<int8_t>), int16_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zerol_v<int8_t>), int16_t(zeror_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, min_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, minr_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, max_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, maxl_v<uint8_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, min_v<uint8_t>), uint16_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, minr_v<uint8_t>), uint16_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, max_v<uint8_t>), uint16_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, maxl_v<uint8_t>), uint16_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, min_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, minr_v<uint8_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, max_v<uint8_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, maxl_v<uint8_t>), uint16_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, min_v<uint8_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, minr_v<uint8_t>), uint16_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, max_v<uint8_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, maxl_v<uint8_t>), uint16_t(max_v<uint16_t>));
+}
+
+TEST(SaturatingMulTest, Test_16_16) {
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, maxl_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zeror_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zerol_v<int16_t>), int16_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, max_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, maxl_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zeror_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zerol_v<int16_t>), int16_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zeror_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zerol_v<int16_t>), int16_t(minr_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, minr_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, maxl_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zeror_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zerol_v<int16_t>), int16_t(minrr_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, min_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, minr_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, max_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, maxl_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zeror_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zerol_v<int16_t>), int16_t(zero_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, min_v<int16_t>), int16_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, minr_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, max_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, maxl_v<int16_t>), int16_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zeror_v<int16_t>), int16_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zerol_v<int16_t>), int16_t(zerol_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, min_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, minr_v<int16_t>), int16_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, max_v<int16_t>), int16_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, maxl_v<int16_t>), int16_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zero_v<int16_t>), int16_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zeror_v<int16_t>), int16_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zerol_v<int16_t>), int16_t(zeror_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, minr_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, max_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, maxl_v<uint16_t>), uint16_t(min_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, minr_v<uint16_t>), uint16_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, maxl_v<uint16_t>), uint16_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, minr_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, min_v<uint16_t>), uint16_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, minr_v<uint16_t>), uint16_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, max_v<uint16_t>), uint16_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, maxl_v<uint16_t>), uint16_t(max_v<uint16_t>));
+}
+
+TEST(SaturatingMulTest, Test_16_32) {
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zeror_v<int32_t>), int32_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zerol_v<int32_t>), int32_t(max_v<int16_t>) + zeror_v<int32_t>);
+
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zeror_v<int32_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zerol_v<int32_t>), int32_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zeror_v<int32_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zerol_v<int32_t>), int32_t(minr_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zeror_v<int32_t>), int32_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zerol_v<int32_t>), int32_t(minrr_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, min_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, minr_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, max_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, maxl_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zeror_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zerol_v<int32_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, minr_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, maxl_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zeror_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zerol_v<int32_t>), int32_t(zerol_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, max_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, maxl_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zeror_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zerol_v<int32_t>), int32_t(zeror_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, minr_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, minr_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, maxl_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, minr_v<uint32_t>), uint32_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, minr_v<uint32_t>), uint32_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingMulTest, Test_16_64) {
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zeror_v<int64_t>), int64_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(min_v<int16_t>, zerol_v<int64_t>), int64_t(max_v<int16_t>) + zeror_v<int64_t>);
+
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zeror_v<int64_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int16_t>, zerol_v<int64_t>), int64_t(max_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zeror_v<int64_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(max_v<int16_t>, zerol_v<int64_t>), int64_t(minr_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zeror_v<int64_t>), int64_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int16_t>, zerol_v<int64_t>), int64_t(minrr_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, min_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, minr_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, max_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, maxl_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int16_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, minr_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, maxl_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zeror_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int16_t>, zerol_v<int64_t>), int64_t(zerol_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, max_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zeror_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int16_t>, zerol_v<int64_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint16_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, minr_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint16_t>, maxl_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, minr_v<uint64_t>), uint64_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint16_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, minr_v<uint64_t>), uint64_t(maxl_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint16_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingMulTest, Test_32_8) {
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, min_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, minr_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, max_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, maxl_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zero_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zeror_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zerol_v<int8_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, min_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, minr_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, max_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, maxl_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zero_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zeror_v<int8_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zerol_v<int8_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, min_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, minr_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, max_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, maxl_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zero_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zeror_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zerol_v<int8_t>), int32_t(minr_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, min_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, minr_v<int8_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, max_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, maxl_v<int8_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zero_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zeror_v<int8_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zerol_v<int8_t>), int32_t(minrr_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, min_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, minr_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, max_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, maxl_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zero_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zeror_v<int8_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zerol_v<int8_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, min_v<int8_t>), int32_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, minr_v<int8_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, max_v<int8_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, maxl_v<int8_t>), int32_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zero_v<int8_t>), int32_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zeror_v<int8_t>), int32_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zerol_v<int8_t>), int32_t(zerol_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, min_v<int8_t>), int32_t(max_v<int8_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, minr_v<int8_t>), int32_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, max_v<int8_t>), int32_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, maxl_v<int8_t>), int32_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zero_v<int8_t>), int32_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zeror_v<int8_t>), int32_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zerol_v<int8_t>), int32_t(zeror_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, min_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, minr_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, max_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, maxl_v<uint8_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, min_v<uint8_t>), uint32_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, minr_v<uint8_t>), uint32_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, max_v<uint8_t>), uint32_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, maxl_v<uint8_t>), uint32_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, min_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, minr_v<uint8_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, max_v<uint8_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, maxl_v<uint8_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, min_v<uint8_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, minr_v<uint8_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, max_v<uint8_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, maxl_v<uint8_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingMulTest, Test_32_16) {
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, min_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, minr_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, max_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, maxl_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zero_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zeror_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zerol_v<int16_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, min_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, minr_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, max_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, maxl_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zero_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zeror_v<int16_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zerol_v<int16_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, min_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, minr_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, max_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, maxl_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zero_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zeror_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zerol_v<int16_t>), int32_t(minr_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, min_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, minr_v<int16_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, max_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, maxl_v<int16_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zero_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zeror_v<int16_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zerol_v<int16_t>), int32_t(minrr_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, min_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, minr_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, max_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, maxl_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zero_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zeror_v<int16_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zerol_v<int16_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, min_v<int16_t>), int32_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, minr_v<int16_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, max_v<int16_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, maxl_v<int16_t>), int32_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zero_v<int16_t>), int32_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zeror_v<int16_t>), int32_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zerol_v<int16_t>), int32_t(zerol_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, min_v<int16_t>), int32_t(max_v<int16_t>) + zeror_v<int32_t>);
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, minr_v<int16_t>), int32_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, max_v<int16_t>), int32_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, maxl_v<int16_t>), int32_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zero_v<int16_t>), int32_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zeror_v<int16_t>), int32_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zerol_v<int16_t>), int32_t(zeror_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, min_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, minr_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, max_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, maxl_v<uint16_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, min_v<uint16_t>), uint32_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, minr_v<uint16_t>), uint32_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, max_v<uint16_t>), uint32_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, maxl_v<uint16_t>), uint32_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, min_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, minr_v<uint16_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, max_v<uint16_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, maxl_v<uint16_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, min_v<uint16_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, minr_v<uint16_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, max_v<uint16_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, maxl_v<uint16_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingMulTest, Test_32_32) {
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zeror_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zerol_v<int32_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, max_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, maxl_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zeror_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zerol_v<int32_t>), int32_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zeror_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zerol_v<int32_t>), int32_t(minr_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, minr_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, maxl_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zeror_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zerol_v<int32_t>), int32_t(minrr_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, min_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, minr_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, max_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, maxl_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zeror_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zerol_v<int32_t>), int32_t(zero_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, min_v<int32_t>), int32_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, minr_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, max_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, maxl_v<int32_t>), int32_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zeror_v<int32_t>), int32_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zerol_v<int32_t>), int32_t(zerol_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, min_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, minr_v<int32_t>), int32_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, max_v<int32_t>), int32_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, maxl_v<int32_t>), int32_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zero_v<int32_t>), int32_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zeror_v<int32_t>), int32_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zerol_v<int32_t>), int32_t(zeror_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, minr_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, max_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, maxl_v<uint32_t>), uint32_t(min_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, minr_v<uint32_t>), uint32_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, maxl_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, minr_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, min_v<uint32_t>), uint32_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, minr_v<uint32_t>), uint32_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, max_v<uint32_t>), uint32_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, maxl_v<uint32_t>), uint32_t(max_v<uint32_t>));
+}
+
+TEST(SaturatingMulTest, Test_32_64) {
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zeror_v<int64_t>), int64_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(min_v<int32_t>, zerol_v<int64_t>), int64_t(max_v<int32_t>) + zeror_v<int64_t>);
+
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zeror_v<int64_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int32_t>, zerol_v<int64_t>), int64_t(max_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zeror_v<int64_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(max_v<int32_t>, zerol_v<int64_t>), int64_t(minr_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zeror_v<int64_t>), int64_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int32_t>, zerol_v<int64_t>), int64_t(minrr_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, min_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, minr_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, max_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, maxl_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int32_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, minr_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, maxl_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zeror_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int32_t>, zerol_v<int64_t>), int64_t(zerol_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, max_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zeror_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int32_t>, zerol_v<int64_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint32_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, minr_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint32_t>, maxl_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, minr_v<uint64_t>), uint64_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint32_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, minr_v<uint64_t>), uint64_t(maxl_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint32_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingMulTest, Test_64_8) {
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, min_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, minr_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, max_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, maxl_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zero_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zeror_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zerol_v<int8_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, min_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, minr_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, max_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, maxl_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zero_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zeror_v<int8_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zerol_v<int8_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, min_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, minr_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, max_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, maxl_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zero_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zeror_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zerol_v<int8_t>), int64_t(minr_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, min_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, minr_v<int8_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, max_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, maxl_v<int8_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zero_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zeror_v<int8_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zerol_v<int8_t>), int64_t(minrr_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, min_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, minr_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, max_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, maxl_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zero_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zeror_v<int8_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zerol_v<int8_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, min_v<int8_t>), int64_t(min_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, minr_v<int8_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, max_v<int8_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, maxl_v<int8_t>), int64_t(maxl_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zero_v<int8_t>), int64_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zeror_v<int8_t>), int64_t(zeror_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zerol_v<int8_t>), int64_t(zerol_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, min_v<int8_t>), int64_t(max_v<int8_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, minr_v<int8_t>), int64_t(max_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, max_v<int8_t>), int64_t(minr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, maxl_v<int8_t>), int64_t(minrr_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zero_v<int8_t>), int64_t(zero_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zeror_v<int8_t>), int64_t(zerol_v<int8_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zerol_v<int8_t>), int64_t(zeror_v<int8_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, min_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, minr_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, max_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, maxl_v<uint8_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, min_v<uint8_t>), uint64_t(min_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, minr_v<uint8_t>), uint64_t(minr_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, max_v<uint8_t>), uint64_t(max_v<uint8_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, maxl_v<uint8_t>), uint64_t(maxl_v<uint8_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, min_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, minr_v<uint8_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, max_v<uint8_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, maxl_v<uint8_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, min_v<uint8_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, minr_v<uint8_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, max_v<uint8_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, maxl_v<uint8_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingMulTest, Test_64_16) {
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, min_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, minr_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, max_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, maxl_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zero_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zeror_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zerol_v<int16_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, min_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, minr_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, max_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, maxl_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zero_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zeror_v<int16_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zerol_v<int16_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, min_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, minr_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, max_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, maxl_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zero_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zeror_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zerol_v<int16_t>), int64_t(minr_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, min_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, minr_v<int16_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, max_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, maxl_v<int16_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zero_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zeror_v<int16_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zerol_v<int16_t>), int64_t(minrr_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, min_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, minr_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, max_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, maxl_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zero_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zeror_v<int16_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zerol_v<int16_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, min_v<int16_t>), int64_t(min_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, minr_v<int16_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, max_v<int16_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, maxl_v<int16_t>), int64_t(maxl_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zero_v<int16_t>), int64_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zeror_v<int16_t>), int64_t(zeror_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zerol_v<int16_t>), int64_t(zerol_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, min_v<int16_t>), int64_t(max_v<int16_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, minr_v<int16_t>), int64_t(max_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, max_v<int16_t>), int64_t(minr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, maxl_v<int16_t>), int64_t(minrr_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zero_v<int16_t>), int64_t(zero_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zeror_v<int16_t>), int64_t(zerol_v<int16_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zerol_v<int16_t>), int64_t(zeror_v<int16_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, min_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, minr_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, max_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, maxl_v<uint16_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, min_v<uint16_t>), uint64_t(min_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, minr_v<uint16_t>), uint64_t(minr_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, max_v<uint16_t>), uint64_t(max_v<uint16_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, maxl_v<uint16_t>), uint64_t(maxl_v<uint16_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, min_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, minr_v<uint16_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, max_v<uint16_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, maxl_v<uint16_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, min_v<uint16_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, minr_v<uint16_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, max_v<uint16_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, maxl_v<uint16_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingMulTest, Test_64_32) {
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, min_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, minr_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, max_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, maxl_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zero_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zeror_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zerol_v<int32_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, min_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, minr_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, max_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, maxl_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zero_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zeror_v<int32_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zerol_v<int32_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, min_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, minr_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, max_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, maxl_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zero_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zeror_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zerol_v<int32_t>), int64_t(minr_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, min_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, minr_v<int32_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, max_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, maxl_v<int32_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zero_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zeror_v<int32_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zerol_v<int32_t>), int64_t(minrr_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, min_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, minr_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, max_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, maxl_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zero_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zeror_v<int32_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zerol_v<int32_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, min_v<int32_t>), int64_t(min_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, minr_v<int32_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, max_v<int32_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, maxl_v<int32_t>), int64_t(maxl_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zero_v<int32_t>), int64_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zeror_v<int32_t>), int64_t(zeror_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zerol_v<int32_t>), int64_t(zerol_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, min_v<int32_t>), int64_t(max_v<int32_t>) + zeror_v<int64_t>);
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, minr_v<int32_t>), int64_t(max_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, max_v<int32_t>), int64_t(minr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, maxl_v<int32_t>), int64_t(minrr_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zero_v<int32_t>), int64_t(zero_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zeror_v<int32_t>), int64_t(zerol_v<int32_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zerol_v<int32_t>), int64_t(zeror_v<int32_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, min_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, minr_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, max_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, maxl_v<uint32_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, min_v<uint32_t>), uint64_t(min_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, minr_v<uint32_t>), uint64_t(minr_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, max_v<uint32_t>), uint64_t(max_v<uint32_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, maxl_v<uint32_t>), uint64_t(maxl_v<uint32_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, min_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, minr_v<uint32_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, max_v<uint32_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, maxl_v<uint32_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, min_v<uint32_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, minr_v<uint32_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, max_v<uint32_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, maxl_v<uint32_t>), uint64_t(max_v<uint64_t>));
+}
+
+TEST(SaturatingMulTest, Test_64_64) {
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zeror_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(min_v<int64_t>, zerol_v<int64_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, max_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, maxl_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zeror_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<int64_t>, zerol_v<int64_t>), int64_t(max_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zeror_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(max_v<int64_t>, zerol_v<int64_t>), int64_t(minr_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, minr_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, maxl_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zeror_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<int64_t>, zerol_v<int64_t>), int64_t(minrr_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, min_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, minr_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, max_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, maxl_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zeror_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zero_v<int64_t>, zerol_v<int64_t>), int64_t(zero_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, min_v<int64_t>), int64_t(min_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, minr_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, max_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, maxl_v<int64_t>), int64_t(maxl_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zeror_v<int64_t>), int64_t(zeror_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zeror_v<int64_t>, zerol_v<int64_t>), int64_t(zerol_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, min_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, minr_v<int64_t>), int64_t(max_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, max_v<int64_t>), int64_t(minr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, maxl_v<int64_t>), int64_t(minrr_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zero_v<int64_t>), int64_t(zero_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zeror_v<int64_t>), int64_t(zerol_v<int64_t>));
+    EXPECT_THAT(saturating_mul(zerol_v<int64_t>, zerol_v<int64_t>), int64_t(zeror_v<int64_t>));
+
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, minr_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, max_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(min_v<uint64_t>, maxl_v<uint64_t>), uint64_t(min_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, minr_v<uint64_t>), uint64_t(minr_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(minr_v<uint64_t>, maxl_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, minr_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(max_v<uint64_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, min_v<uint64_t>), uint64_t(min_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, minr_v<uint64_t>), uint64_t(maxl_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, max_v<uint64_t>), uint64_t(max_v<uint64_t>));
+    EXPECT_THAT(saturating_mul(maxl_v<uint64_t>, maxl_v<uint64_t>), uint64_t(max_v<uint64_t>));
+}