diff --git a/.gitignore b/.gitignore
index 1561cf00..2bdcfb1c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -386,3 +386,4 @@ test/vs2022/Debug MSVC C++20 - No virtual messages
 examples/MutexMessageRouter/.vs
 support/time remaining test.xlsx
 test/vs2022/Debug MSVC C++20 - Force C++03
+test/vs2022/Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser
diff --git a/cmake/GetGitRevisionDescription.cmake b/cmake/GetGitRevisionDescription.cmake
index 0a203502..07ec5faf 100644
--- a/cmake/GetGitRevisionDescription.cmake
+++ b/cmake/GetGitRevisionDescription.cmake
@@ -59,7 +59,7 @@ get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
 # function returns an empty string via _git_dir_var.
 #
 # Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and
-# neither foo nor bar contain a file/directory .git. This wil return
+# neither foo nor bar contain a file/directory .git. This will return
 # C:/bla/.git
 #
 function(_git_find_closest_git_dir _start_dir _git_dir_var)
diff --git a/examples/FunctionInterruptSimulation-Delegates/FunctionInterruptSimulation.cpp b/examples/FunctionInterruptSimulation-Delegates/FunctionInterruptSimulation.cpp
index 2fb61c92..bbf6debf 100644
--- a/examples/FunctionInterruptSimulation-Delegates/FunctionInterruptSimulation.cpp
+++ b/examples/FunctionInterruptSimulation-Delegates/FunctionInterruptSimulation.cpp
@@ -119,7 +119,7 @@ Uart  uart1(0, USART1_IRQ_HANDLER);
 Uart  uart2(1, USART2_IRQ_HANDLER);
 
 // Declare a global callback for the timer.
-// Uses the most efficient callback type for a class, as everthing is known at compile time.
+// Uses the most efficient callback type for a class, as everything is known at compile time.
 etl::delegate<void(size_t)> timer_member_callback = etl::delegate<void(size_t)>::create<Timer, timer, &Timer::InterruptHandler>();
 
 // Declare the callbacks for the free functions.
diff --git a/examples/FunctionInterruptSimulation/FunctionInterruptSimulation.cpp b/examples/FunctionInterruptSimulation/FunctionInterruptSimulation.cpp
index cee73877..9eb6cb98 100644
--- a/examples/FunctionInterruptSimulation/FunctionInterruptSimulation.cpp
+++ b/examples/FunctionInterruptSimulation/FunctionInterruptSimulation.cpp
@@ -119,7 +119,7 @@ Uart  uart1(0, USART1_IRQ_HANDLER);
 Uart  uart2(1, USART2_IRQ_HANDLER);
 
 // Declare a global callback for the timer.
-// Uses the most efficient callback type for a class, as everthing is known at compile time.
+// Uses the most efficient callback type for a class, as everything is known at compile time.
 etl::function_imp<Timer, size_t, timer, &Timer::InterruptHandler> timer_member_callback;
 
 // Declare the callbacks for the free functions.
diff --git a/include/etl/algorithm.h b/include/etl/algorithm.h
index cc989d15..313a2c87 100644
--- a/include/etl/algorithm.h
+++ b/include/etl/algorithm.h
@@ -169,6 +169,18 @@ namespace etl
     return first2;
   }
 
+  //***************************************************************************
+  // generate
+  template <typename TIterator, typename TFunction>
+  ETL_CONSTEXPR14
+  void generate(TIterator db, TIterator de, TFunction funct)
+  {
+    while (db != de)
+    {
+      *db++ = funct();
+    }
+  }
+
   //***************************************************************************
   // copy
 #if ETL_USING_STL && ETL_USING_CPP20 
@@ -2009,9 +2021,7 @@ namespace etl
   template <typename TIterator, typename T>
   ETL_CONSTEXPR14
   TIterator remove(TIterator first, TIterator last, const T& value)
-  {
-    first = etl::find(first, last, value);
-      
+  {    
     if (first != last)
     {
       TIterator itr = first;
@@ -2039,8 +2049,6 @@ namespace etl
   ETL_CONSTEXPR14
   TIterator remove_if(TIterator first, TIterator last, TUnaryPredicate predicate)
   {
-    first = etl::find_if(first, last, predicate);
-
     if (first != last)
     {
       TIterator itr = first;
@@ -2177,7 +2185,7 @@ namespace etl
   //***************************************************************************
   /// copy_if
   /// A safer form of copy_if where it terminates when the first end iterator is reached.
-  /// There is currently no STL equivelent.
+  /// There is currently no STL equivalent.
   ///\ingroup algorithm
   //***************************************************************************
   template <typename TInputIterator,
@@ -3065,6 +3073,154 @@ namespace etl
     return multimin_iter_compare(compare, t, multimin_iter_compare(compare, tx...));
   }
 #endif
+
+  //***************************************************************************
+  /// partition
+  /// For forward iterators only
+  /// Does at most etl::distance(first, last) swaps.
+  //***************************************************************************
+  template <typename TIterator, typename TPredicate>
+  ETL_CONSTEXPR14 
+  typename etl::enable_if<etl::is_forward_iterator<TIterator>::value, TIterator>::type
+    partition(TIterator first, TIterator last, TPredicate predicate)
+  {
+    first = etl::find_if_not(first, last, predicate);
+
+    if (first == last)
+    {
+      return first;
+    }
+
+    for (TIterator i = etl::next(first); i != last; ++i)
+    {
+      if (predicate(*i))
+      {
+        using ETL_OR_STD::swap;
+        swap(*i, *first);
+        ++first;
+      }
+    }
+
+    return first;
+  }
+
+  //***************************************************************************
+  /// partition
+  /// For iterators that support bidirectional iteration.
+  /// Does at most (etl::distance(first, last) / 2) swaps.
+  //***************************************************************************
+  template <typename TIterator, typename TPredicate>
+  ETL_CONSTEXPR14
+  typename etl::enable_if<etl::is_bidirectional_iterator_concept<TIterator>::value, TIterator>::type
+    partition(TIterator first, TIterator last, TPredicate predicate) 
+  {
+    while (first != last)
+    {
+      first = etl::find_if_not(first, last, predicate);
+
+      if (first == last)
+      {
+        break;
+      }
+
+      last = etl::find_if(etl::reverse_iterator<TIterator>(last),
+                          etl::reverse_iterator<TIterator>(first),
+                          predicate).base();
+
+      if (first == last)
+      {
+        break;
+      }
+
+      --last;
+      using ETL_OR_STD::swap;
+      swap(*first, *last);
+      ++first;
+    }
+
+    return first;
+  }
+
+  //*********************************************************
+  namespace private_algorithm
+  {
+    using ETL_OR_STD::swap;
+
+    template <typename TIterator, typename TCompare>
+#if (ETL_USING_CPP20 && ETL_USING_STL) || (ETL_USING_CPP14 && ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST))
+    constexpr
+#endif
+    TIterator nth_partition(TIterator first, TIterator last, TCompare compare)
+    {
+      typedef typename etl::iterator_traits<TIterator>::value_type value_type;
+
+      TIterator  pivot = last; // Maybe find a better pivot choice?
+      value_type pivot_value = *pivot;
+
+      // Swap the pivot with the last, if necessary.
+      if (pivot != last)
+      {
+        swap(*pivot, *last);
+      }
+
+      TIterator i = first;
+
+      for (TIterator j = first; j < last; ++j)
+      {
+        if (!compare(pivot_value, *j)) // Hack to get '*j <= pivot_value' in terms of 'pivot_value < *j'
+        {
+          swap(*i, *j);
+          ++i;
+        }
+      }
+
+      swap(*i, *last);
+
+      return i;
+    }
+  }
+
+  //*********************************************************
+  /// nth_element
+  /// see https://en.cppreference.com/w/cpp/algorithm/nth_element
+  //*********************************************************
+#if ETL_USING_CPP11
+  template <typename TIterator, typename TCompare = etl::less<typename etl::iterator_traits<TIterator>::value_type> >
+#else
+  template <typename TIterator, typename TCompare>
+#endif
+#if (ETL_USING_CPP20 && ETL_USING_STL) || (ETL_USING_CPP14 && ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST))
+  constexpr
+#endif
+  typename etl::enable_if<etl::is_random_access_iterator_concept<TIterator>::value, void>::type
+    nth_element(TIterator first, TIterator nth, TIterator last, TCompare compare = TCompare())
+  {
+    if (first == last)
+    {
+      return;
+    }
+
+    // 'last' must point to the actual last value.
+    --last;
+
+    while (first <= last)
+    {
+      TIterator p = private_algorithm::nth_partition(first, last, compare);
+
+      if (p == nth)
+      {
+        return;
+      }
+      else if (p > nth)
+      {
+        last = p - 1;
+      }
+      else
+      {
+        first = p + 1;
+      }
+    }
+  }
 }
 
 #include "private/minmax_pop.h"
diff --git a/include/etl/array.h b/include/etl/array.h
index 52f0f654..caca9e7e 100644
--- a/include/etl/array.h
+++ b/include/etl/array.h
@@ -94,15 +94,15 @@ namespace etl
 
     static ETL_CONSTANT size_t SIZE = SIZE_;
 
-    typedef T                                     value_type;
-    typedef size_t                                size_type;
-    typedef ptrdiff_t                             difference_type;
-    typedef T&                                    reference;
-    typedef const T&                              const_reference;
-    typedef T*                                    pointer;
-    typedef const T*                              const_pointer;
-    typedef T*                                    iterator;
-    typedef const T*                              const_iterator;
+    typedef T         value_type;
+    typedef size_t    size_type;
+    typedef ptrdiff_t difference_type;
+    typedef T&        reference;
+    typedef const T&  const_reference;
+    typedef T*        pointer;
+    typedef const T*  const_pointer;
+    typedef T*        iterator;
+    typedef const T*  const_iterator;
     typedef ETL_OR_STD::reverse_iterator<iterator>       reverse_iterator;
     typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
 
@@ -386,11 +386,12 @@ namespace etl
     /// If the range is smaller than the array then the unused array elements are left unmodified.
     ///\param first The iterator to the first item in the range.
     ///\param last  The iterator to one past the final item in the range.
+    ///\return An iterator to the first unassigned array element, or end().
     //*************************************************************************
     template <typename TIterator>
-    void assign(TIterator first, const TIterator last)
+    iterator assign(TIterator first, const TIterator last)
     {
-      etl::copy_s(first, last, begin(), end());
+      return etl::copy_s(first, last, begin(), end());
     }
 
     //*************************************************************************
@@ -398,15 +399,18 @@ namespace etl
     /// If the range is smaller than the array then the unused array elements are initialised with the supplied value.
     ///\param first The iterator to the first item in the range.
     ///\param last  The iterator to one past the final item in the range.
+    ///\return An iterator to the first array element set to 'value', or end().
     //*************************************************************************
     template <typename TIterator>
-    void assign(TIterator first, const TIterator last, parameter_t value)
+    iterator assign(TIterator first, const TIterator last, parameter_t value)
     {
       // Copy from the range.
-      iterator p = etl::copy(first, last, begin());
+      iterator p = etl::copy_s(first, last, begin(), end());
 
       // Initialise any that are left.
       etl::fill(p, end(), value);
+
+      return p;
     }
 
     //*************************************************************************
diff --git a/include/etl/atomic/atomic_gcc_sync.h b/include/etl/atomic/atomic_gcc_sync.h
index 152279dd..9e7399aa 100644
--- a/include/etl/atomic/atomic_gcc_sync.h
+++ b/include/etl/atomic/atomic_gcc_sync.h
@@ -167,7 +167,7 @@ namespace etl
 
     T operator --(int) volatile
     {
-      return __atomic_fetch_sub(&value, 1), etl::memory_order_seq_cst;
+      return __atomic_fetch_sub(&value, 1, etl::memory_order_seq_cst);
     }
 
     // Add
diff --git a/include/etl/basic_format_spec.h b/include/etl/basic_format_spec.h
index 90a48c1a..36c2d74c 100644
--- a/include/etl/basic_format_spec.h
+++ b/include/etl/basic_format_spec.h
@@ -172,10 +172,10 @@ namespace etl
   static ETL_CONSTANT private_basic_format_spec::base_spec hex(16U);
 
   //*********************************
-  static ETL_CONSTANT private_basic_format_spec::left_spec left;
+  static ETL_CONSTANT private_basic_format_spec::left_spec left = private_basic_format_spec::left_spec();
 
   //*********************************
-  static ETL_CONSTANT private_basic_format_spec::right_spec right;
+  static ETL_CONSTANT private_basic_format_spec::right_spec right = private_basic_format_spec::right_spec();
 
   //*********************************
   static ETL_CONSTANT private_basic_format_spec::boolalpha_spec boolalpha(true);
diff --git a/include/etl/basic_string.h b/include/etl/basic_string.h
index 8afdf18a..6b01c61f 100644
--- a/include/etl/basic_string.h
+++ b/include/etl/basic_string.h
@@ -1262,7 +1262,7 @@ namespace etl
     /// Erases a sequence.
     ///\param position Position to start from.
     ///\param length   Number of characters.
-    ///\return A refernce to this string.
+    ///\return A reference to this string.
     //*********************************************************************
     etl::ibasic_string<T>& erase(size_type position, size_type length_ = npos)
     {
diff --git a/include/etl/basic_string_stream.h b/include/etl/basic_string_stream.h
index e91ee1fe..2b466055 100644
--- a/include/etl/basic_string_stream.h
+++ b/include/etl/basic_string_stream.h
@@ -58,28 +58,28 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Construct from text and format spec.
+    /// Construct from text and format fmt.
     //*************************************************************************
     basic_string_stream(TIString& text_, const TFormat& spec_)
       : text(text_)
-      , spec(spec_)
+      , format(spec_)
     {
     }
 
     //*************************************************************************
-    /// Set the format spec.
+    /// Set the format fmt.
     //*************************************************************************
     void set_format(const TFormat& spec_)
     {
-      spec = spec_;
+      format = spec_;
     }
 
     //*************************************************************************
-    /// Get a const reference to the format spec.
+    /// Get a const reference to the format fmt.
     //*************************************************************************
     const TFormat& get_format() const
     {
-      return spec;
+      return format;
     }
 
     //*************************************************************************
@@ -121,27 +121,27 @@ namespace etl
     //*********************************
     /// TFormat
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, const TFormat& spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, const TFormat& fmt)
     {
-      ss.spec = spec;
+      ss.format = fmt;
       return ss;
     }
 
     //*********************************
     /// etl::base_spec from etl::setbase, etl::bin, etl::oct, etl::dec & etl::hex stream manipulators
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::base_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::base_spec fmt)
     {
-      ss.spec.base(spec.base);
+      ss.format.base(fmt.base);
       return ss;
     }
 
     //*********************************
     /// etl::width_spec from etl::setw stream manipulator
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::width_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::width_spec fmt)
     {
-      ss.spec.width(spec.width);
+      ss.format.width(fmt.width);
       return ss;
     }
 
@@ -149,63 +149,63 @@ namespace etl
     /// etl::fill_spec from etl::setfill stream manipulator
     //*********************************
     template <typename TChar>
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::fill_spec<TChar> spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::fill_spec<TChar> fmt)
     {
-      ss.spec.fill(spec.fill);
+      ss.format.fill(fmt.fill);
       return ss;
     }
 
     //*********************************
     /// etl::precision_spec from etl::setprecision stream manipulator
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::precision_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::precision_spec fmt)
     {
-      ss.spec.precision(spec.precision);
+      ss.format.precision(fmt.precision);
       return ss;
     }
 
     //*********************************
     /// etl::boolalpha_spec from etl::boolalpha & etl::noboolalpha stream manipulators
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::boolalpha_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::boolalpha_spec fmt)
     {
-      ss.spec.boolalpha(spec.boolalpha);
+      ss.format.boolalpha(fmt.boolalpha);
       return ss;
     }
 
     //*********************************
     /// etl::uppercase_spec from etl::uppercase & etl::nouppercase stream manipulators
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::uppercase_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::uppercase_spec fmt)
     {
-      ss.spec.upper_case(spec.upper_case);
+      ss.format.upper_case(fmt.upper_case);
       return ss;
     }
 
     //*********************************
     /// etl::showbase_spec from etl::showbase & etl::noshowbase stream manipulators
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::showbase_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::showbase_spec fmt)
     {
-      ss.spec.show_base(spec.show_base);
+      ss.format.show_base(fmt.show_base);
       return ss;
     }
 
     //*********************************
     /// etl::left_spec from etl::left stream manipulator
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::left_spec /*spec*/)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::left_spec /*fmt*/)
     {
-      ss.spec.left();
+      ss.format.left();
       return ss;
     }
 
     //*********************************
     /// etl::right_spec from etl::left stream manipulator
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::right_spec /*spec*/)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::right_spec /*fmt*/)
     {
-      ss.spec.right();
+      ss.format.right();
       return ss;
     }
 
@@ -214,7 +214,7 @@ namespace etl
     //*********************************
     friend basic_string_stream& operator <<(basic_string_stream& ss, TStringView view)
     {
-      etl::to_string(view, ss.text, ss.spec, true);
+      etl::to_string(view, ss.text, ss.format, true);
       return ss;
     }
 
@@ -241,9 +241,9 @@ namespace etl
     //*********************************
     /// From a string interface
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, const TIString& text)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, const TIString& t)
     {
-      etl::to_string(text, ss.text, ss.spec, true);
+      etl::to_string(t, ss.text, ss.format, true);
       return ss;
     }
 
@@ -251,9 +251,9 @@ namespace etl
     /// From a string
     //*********************************
     template <template <size_t> class TString, size_t SIZE>
-    friend basic_string_stream& operator <<(basic_string_stream& ss, const TString<SIZE>& text)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, const TString<SIZE>& t)
     {
-      const TIString& itext = text;
+      const TIString& itext = t;
       etl::to_string(itext, ss.str(), ss.get_format(), true);
       return ss;
     }
@@ -264,14 +264,14 @@ namespace etl
     template <typename T>
     friend basic_string_stream& operator <<(basic_string_stream& ss, const T& value)
     {
-      etl::to_string(value, ss.text, ss.spec, true);
+      etl::to_string(value, ss.text, ss.format, true);
       return ss;
     }
 
   private:
 
-    TIString&    text;
-    TFormat spec;
+    TIString& text;
+    TFormat   format;
 
     basic_string_stream(const basic_string_stream&) ETL_DELETE;
     basic_string_stream& operator =(const basic_string_stream&) ETL_DELETE;
diff --git a/include/etl/binary.h b/include/etl/binary.h
index f6388562..4ddf6273 100644
--- a/include/etl/binary.h
+++ b/include/etl/binary.h
@@ -343,45 +343,6 @@ namespace etl
     return TReturn((value ^ mask) - mask);
   }
 
-  //***************************************************************************
-  /// Find the position of the first set bit.
-  /// Starts from LSB.
-  ///\ingroup binary
-  //***************************************************************************
-  template <typename T>
-  ETL_CONSTEXPR14 uint_least8_t first_set_bit_position(T value)
-  {
-    return count_trailing_zeros(value);
-  }
-
-  //***************************************************************************
-  /// Find the position of the first clear bit.
-  /// Starts from LSB.
-  ///\ingroup binary
-  //***************************************************************************
-  template <typename T>
-  ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position(T value)
-  {
-    value = ~value;
-    return count_trailing_zeros(value);
-  }
-
-  //***************************************************************************
-  /// Find the position of the first bit that is clear or set.
-  /// Starts from LSB.
-  ///\ingroup binary
-  //***************************************************************************
-  template <typename T>
-  ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
-  {
-    if (!state)
-    {
-      value = ~value;
-    }
-
-    return count_trailing_zeros(value);
-  }
-
   //***************************************************************************
   /// Gets the value of the bit at POSITION
   /// Starts from LSB.
@@ -2097,6 +2058,45 @@ namespace etl
     return static_cast<T>(count_leading_ones(static_cast<unsigned_t>(value)));
   }
 
+  //***************************************************************************
+  /// Find the position of the first set bit.
+  /// Starts from LSB.
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  ETL_CONSTEXPR14 uint_least8_t first_set_bit_position(T value)
+  {
+    return count_trailing_zeros(value);
+  }
+
+  //***************************************************************************
+  /// Find the position of the first clear bit.
+  /// Starts from LSB.
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position(T value)
+  {
+    value = ~value;
+    return count_trailing_zeros(value);
+  }
+
+  //***************************************************************************
+  /// Find the position of the first bit that is clear or set.
+  /// Starts from LSB.
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
+  {
+    if (!state)
+    {
+      value = ~value;
+    }
+
+    return count_trailing_zeros(value);
+  }
+
 #if ETL_USING_8BIT_TYPES
   //*****************************************************************************
   /// Binary interleave
@@ -2276,6 +2276,111 @@ namespace etl
     return msb_mask<T, NBits>::value;
   }
 
+  //***************************************************************************
+  /// Bit 'not' a value
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  struct binary_not : public etl::unary_function<T, T>
+  {
+    //***********************************
+    ETL_NODISCARD
+    ETL_CONSTEXPR
+    T operator ()(T value) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
+
+      return ~value;
+    }
+  };
+
+  //***************************************************************************
+  /// Bit 'and' a value with another
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  struct binary_and : public etl::unary_function<T, T>
+  {
+    //***********************************
+    ETL_CONSTEXPR 
+    explicit binary_and(T parameter_) ETL_NOEXCEPT
+      : parameter(parameter_)
+    {
+    }
+
+    //***********************************
+    ETL_NODISCARD
+    ETL_CONSTEXPR 
+    T operator ()(T value) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
+
+      return value & parameter;
+    }
+
+  private:
+
+    T parameter;
+  };
+
+  //***************************************************************************
+  /// Bit 'or' a value with another
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  struct binary_or : public etl::unary_function<T, T>
+  {
+    //***********************************
+    ETL_CONSTEXPR
+    explicit binary_or(T parameter_) ETL_NOEXCEPT
+      : parameter(parameter_)
+    {
+    }
+
+    //***********************************
+    ETL_NODISCARD
+    ETL_CONSTEXPR
+    T operator ()(T value) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
+
+      return value | parameter;
+    }
+
+  private:
+
+    T parameter;
+  };
+
+  //***************************************************************************
+  /// Bit 'exclusive-or' a value with another
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  struct binary_xor : public etl::unary_function<T, T>
+  {
+    //***********************************
+    ETL_CONSTEXPR
+    explicit binary_xor(T parameter_) ETL_NOEXCEPT
+      : parameter(parameter_)
+    {
+    }
+
+    //***********************************
+    ETL_NODISCARD
+    ETL_CONSTEXPR
+    T operator ()(T value) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
+
+      return value ^ parameter;
+    }
+
+  private:
+
+    T parameter;
+  };
+
   //***************************************************************************
   /// 8 bit binary byte constants.
   ///\ingroup binary
diff --git a/include/etl/bit_stream.h b/include/etl/bit_stream.h
index 6dcc50f7..7c5b557e 100644
--- a/include/etl/bit_stream.h
+++ b/include/etl/bit_stream.h
@@ -861,7 +861,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Sets the function to call afer every write.
+    /// Sets the function to call after every write.
     //***************************************************************************
     void set_callback(callback_type callback_)
     {
@@ -869,7 +869,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Gets the function to call afer every write.
+    /// Gets the function to call after every write.
     //***************************************************************************
     callback_type get_callback() const
     {
diff --git a/include/etl/bloom_filter.h b/include/etl/bloom_filter.h
index 711a151b..5d35128c 100644
--- a/include/etl/bloom_filter.h
+++ b/include/etl/bloom_filter.h
@@ -62,17 +62,17 @@ namespace etl
   /// An implementation of a bloom filter.
   /// Allows up to three hashes to be defined.
   /// Hashes must support the () operator and define 'argument_type'.
-  ///\tparam DESIRED_WIDTH The desired number of hash results that can be stored. Rounded up to best fit the underlying bitset.
+  ///\tparam Desired_Width The desired number of hash results that can be stored. Rounded up to best fit the underlying bitset.
   ///\tparam THash1        The first hash generator class.
   ///\tparam THash2        The second hash generator class. If omitted, uses the null hash.
   ///\tparam THash3        The third hash generator class.  If omitted, uses the null hash.
   /// The hash classes must define <b>argument_type</b>.
   ///\ingroup bloom_filter
   //***************************************************************************
-  template <size_t DESIRED_WIDTH,
-            typename     THash1,
-            typename     THash2 = private_bloom_filter::null_hash,
-            typename     THash3 = private_bloom_filter::null_hash>
+  template <size_t   Desired_Width,
+            typename THash1,
+            typename THash2 = private_bloom_filter::null_hash,
+            typename THash3 = private_bloom_filter::null_hash>
   class bloom_filter
   {
   private:
@@ -85,7 +85,7 @@ namespace etl
     enum
     {
       // Make the most efficient use of the bitset.
-      WIDTH = etl::bitset<DESIRED_WIDTH>::ALLOCATED_BITS
+      WIDTH = etl::bitset<Desired_Width>::Allocated_Bits
     };
 
     //***************************************************************************
diff --git a/include/etl/byte_stream.h b/include/etl/byte_stream.h
index aaa9d8a4..17d58f4e 100644
--- a/include/etl/byte_stream.h
+++ b/include/etl/byte_stream.h
@@ -69,7 +69,7 @@ namespace etl
     byte_stream_writer(etl::span<char> span_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(span_.begin())
       , pcurrent(span_.begin())
-      , length(span_.size_bytes())
+      , stream_length(span_.size_bytes())
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -81,7 +81,7 @@ namespace etl
     byte_stream_writer(etl::span<unsigned char> span_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(reinterpret_cast<char*>(span_.begin()))
       , pcurrent(reinterpret_cast<char*>(span_.begin()))
-      , length(span_.size_bytes())
+      , stream_length(span_.size_bytes())
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -93,7 +93,7 @@ namespace etl
     byte_stream_writer(void* begin_, void* end_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(reinterpret_cast<char*>(begin_))
       , pcurrent(reinterpret_cast<char*>(begin_))
-      , length(etl::distance(reinterpret_cast<char*>(begin_), reinterpret_cast<char*>(end_)))
+      , stream_length(etl::distance(reinterpret_cast<char*>(begin_), reinterpret_cast<char*>(end_)))
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -105,7 +105,7 @@ namespace etl
     byte_stream_writer(void* begin_, size_t length_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(reinterpret_cast<char*>(begin_))
       , pcurrent(reinterpret_cast<char*>(begin_))
-      , length(length_)
+      , stream_length(length_)
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -118,7 +118,7 @@ namespace etl
     byte_stream_writer(T(&begin_)[Size], etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(begin_)
       , pcurrent(begin_)
-      , length(begin_ + (Size * sizeof(T)))
+      , stream_length(begin_ + (Size * sizeof(T)))
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -333,7 +333,7 @@ namespace etl
     //***************************************************************************
     etl::span<char> free_data()
     {
-      return etl::span<char>(pcurrent, pdata + length);
+      return etl::span<char>(pcurrent, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -341,7 +341,7 @@ namespace etl
     //***************************************************************************
     etl::span<const char> free_data() const
     {
-      return etl::span<const char>(pcurrent, pdata + length);
+      return etl::span<const char>(pcurrent, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -349,7 +349,7 @@ namespace etl
     //***************************************************************************
     etl::span<char> data()
     {
-      return etl::span<char>(pdata, pdata + length);
+      return etl::span<char>(pdata, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -357,7 +357,7 @@ namespace etl
     //***************************************************************************
     etl::span<const char> data() const
     {
-      return etl::span<const char>(pdata, pdata + length);
+      return etl::span<const char>(pdata, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -389,7 +389,7 @@ namespace etl
     //***************************************************************************
     size_t capacity() const
     {
-      return length;
+      return stream_length;
     }
 
     //***************************************************************************
@@ -410,7 +410,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Sets the function to call afer every write.
+    /// Sets the function to call after every write.
     //***************************************************************************
     void set_callback(callback_type callback_)
     {
@@ -418,7 +418,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Gets the function to call afer every write.
+    /// Gets the function to call after every write.
     //***************************************************************************
     callback_type get_callback() const
     {
@@ -481,7 +481,7 @@ namespace etl
 
     char* const       pdata;             ///< The start of the byte stream buffer.
     char*             pcurrent;          ///< The current position in the byte stream buffer.
-    const size_t      length;            ///< The length of the byte stream buffer.
+    const size_t      stream_length;     ///< The length of the byte stream buffer.
     const etl::endian stream_endianness; ///< The endianness of the stream data.
     callback_type     callback;          ///< An optional callback on every step on the write buffer.
   };
@@ -503,7 +503,7 @@ namespace etl
     byte_stream_reader(etl::span<char> span_, etl::endian stream_endianness_)
       : pdata(span_.begin())
       , pcurrent(span_.begin())
-      , length(span_.size_bytes())
+      , stream_length(span_.size_bytes())
       , stream_endianness(stream_endianness_)
     {
     }
@@ -514,7 +514,7 @@ namespace etl
     byte_stream_reader(etl::span<const char> span_, etl::endian stream_endianness_)
       : pdata(span_.begin())
       , pcurrent(span_.begin())
-      , length(span_.size_bytes())
+      , stream_length(span_.size_bytes())
       , stream_endianness(stream_endianness_)
     {
     }
@@ -525,7 +525,7 @@ namespace etl
     byte_stream_reader(const void* begin_, const void* end_, etl::endian stream_endianness_)
       : pdata(reinterpret_cast<const char*>(begin_))
       , pcurrent(reinterpret_cast<const char*>(begin_))
-      , length(etl::distance(reinterpret_cast<const char*>(begin_), reinterpret_cast<const char*>(end_)))
+      , stream_length(etl::distance(reinterpret_cast<const char*>(begin_), reinterpret_cast<const char*>(end_)))
       , stream_endianness(stream_endianness_)
     {
     }
@@ -536,7 +536,7 @@ namespace etl
     byte_stream_reader(const void* begin_, size_t length_, etl::endian stream_endianness_)
       : pdata(reinterpret_cast<const char*>(begin_))
       , pcurrent(reinterpret_cast<const char*>(begin_))
-      , length(length_)
+      , stream_length(length_)
       , stream_endianness(stream_endianness_)
     {
     }
@@ -548,7 +548,7 @@ namespace etl
     byte_stream_reader(T(&begin_)[Size], etl::endian stream_endianness_)
       : pdata(begin_)
       , pcurrent(begin_)
-      , length(begin_ + (Size * sizeof(T)))
+      , stream_length(begin_ + (Size * sizeof(T)))
       , stream_endianness(stream_endianness_)
     {
     }
@@ -560,7 +560,7 @@ namespace etl
     byte_stream_reader(const T(&begin_)[Size], etl::endian stream_endianness_)
       : pdata(begin_)
       , pcurrent(begin_)
-      , length(begin_ + (Size * sizeof(T)))
+      , stream_length(begin_ + (Size * sizeof(T)))
       , stream_endianness(stream_endianness_)
     {
     }
@@ -766,7 +766,7 @@ namespace etl
     //***************************************************************************
     etl::span<const char> free_data() const
     {
-      return etl::span<const char>(pcurrent, pdata + length);
+      return etl::span<const char>(pcurrent, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -774,7 +774,7 @@ namespace etl
     //***************************************************************************
     etl::span<const char> data() const
     {
-      return etl::span<const char>(pdata, pdata + length);
+      return etl::span<const char>(pdata, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -790,7 +790,7 @@ namespace etl
     //***************************************************************************
     size_t size_bytes() const
     {
-      return length;
+      return stream_length;
     }
 
     //***************************************************************************
@@ -801,7 +801,7 @@ namespace etl
     {
       size_t used = etl::distance(pdata, pcurrent);
 
-      return (length - used) / sizeof(T);
+      return (stream_length - used) / sizeof(T);
     }
 
     //***************************************************************************
@@ -855,7 +855,7 @@ namespace etl
 
     const char* const pdata;             ///< The start of the byte stream buffer.
     const char*       pcurrent;          ///< The current position in the byte stream buffer.
-    const size_t      length;            ///< The length of the byte stream buffer.
+    const size_t      stream_length;     ///< The length of the byte stream buffer.
     const etl::endian stream_endianness; ///< The endianness of the stream data.
   };
 
diff --git a/include/etl/callback_timer.h b/include/etl/callback_timer.h
index e4b5596d..9c833dbb 100644
--- a/include/etl/callback_timer.h
+++ b/include/etl/callback_timer.h
@@ -708,12 +708,26 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      return !active_list.empty();
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
-      uint32_t delta = active_list.front().delta;
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
+      if (has_active_timer())
+      {
+        delta = active_list.front().delta;
+      }
 
       return delta;
     }
diff --git a/include/etl/callback_timer_atomic.h b/include/etl/callback_timer_atomic.h
index 0d12fc29..2a886de2 100644
--- a/include/etl/callback_timer_atomic.h
+++ b/include/etl/callback_timer_atomic.h
@@ -297,13 +297,31 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      ++process_semaphore;
+      bool result = !active_list.empty();
+      --process_semaphore;
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       ++process_semaphore;
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
       --process_semaphore;
 
       return delta;
diff --git a/include/etl/callback_timer_interrupt.h b/include/etl/callback_timer_interrupt.h
index bc3fda5d..831565aa 100644
--- a/include/etl/callback_timer_interrupt.h
+++ b/include/etl/callback_timer_interrupt.h
@@ -301,14 +301,30 @@ namespace etl
     }
 
     //*******************************************
-    /// Get the time to the next timer event.
+    /// Check if there is an active timer.
     //*******************************************
-    uint32_t time_to_next() const
+    bool has_active_timer() const
     {
       TInterruptGuard guard;
       (void)guard; // Silence 'unused variable warnings.
+      return !active_list.empty();
+    }
 
-      uint32_t delta = active_list.front().delta;
+    //*******************************************
+    /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
+    //*******************************************
+    uint32_t time_to_next() const
+    {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
+      TInterruptGuard guard;
+      (void)guard; // Silence 'unused variable warnings.
+
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
 
       return delta;
     }
diff --git a/include/etl/callback_timer_locked.h b/include/etl/callback_timer_locked.h
index bfd6952c..c7480ba8 100644
--- a/include/etl/callback_timer_locked.h
+++ b/include/etl/callback_timer_locked.h
@@ -309,13 +309,31 @@ namespace etl
       unlock   = unlock_;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      lock();
+      bool result = !active_list.empty();
+      unlock();
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       lock();
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
       unlock();
 
       return delta;
diff --git a/include/etl/char_traits.h b/include/etl/char_traits.h
index 8ffeb7fd..a85bf670 100644
--- a/include/etl/char_traits.h
+++ b/include/etl/char_traits.h
@@ -153,7 +153,7 @@ namespace etl
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 static size_t length(const char_type* str, size_t max_length)
+    static ETL_CONSTEXPR14 size_t length(const char_type* str, size_t max_length)
     {
       size_t count = 0UL;
 
diff --git a/include/etl/circular_buffer.h b/include/etl/circular_buffer.h
index a099ca4a..0902f0da 100644
--- a/include/etl/circular_buffer.h
+++ b/include/etl/circular_buffer.h
@@ -246,6 +246,22 @@ namespace etl
         return &picb->pbuffer[current];
       }
 
+      //*************************************************************************
+      /// [] operator
+      //*************************************************************************
+      reference operator [](size_t index)
+      {
+        return pbuffer[(current + index) % picb->buffer_size];
+      }
+
+      //*************************************************************************
+      /// [] operator
+      //*************************************************************************
+      const_reference operator [](size_t index) const
+      {
+        return pbuffer[(current + index) % picb->buffer_size];
+      }
+
       //*************************************************************************
       /// Pre-increment.
       //*************************************************************************
@@ -335,6 +351,18 @@ namespace etl
         return temp;
       }
 
+      //*************************************************************************
+      /// Add offset.
+      //*************************************************************************
+      friend iterator operator +(int n, const iterator& rhs)
+      {
+        iterator temp = rhs;
+
+        temp += n;
+
+        return temp;
+      }
+
       //*************************************************************************
       /// Subtract offset.
       //*************************************************************************
@@ -517,6 +545,14 @@ namespace etl
         return &(picb->pbuffer[current]);
       }
 
+      //*************************************************************************
+      /// [] operator
+      //*************************************************************************
+      const_reference operator [](size_t index) const
+      {
+        return pbuffer[(current + index) % picb->buffer_size];
+      }
+
       //*************************************************************************
       /// Pre-increment.
       //*************************************************************************
@@ -998,22 +1034,6 @@ namespace etl
       return distance(rhs, lhs);
     }
 
-    //*************************************************************************
-    /// - operator for reverse_iterator
-    //*************************************************************************
-    friend difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs)
-    {
-      return distance(lhs.base(), rhs.base());
-    }
-
-    //*************************************************************************
-    /// - operator for const_reverse_iterator
-    //*************************************************************************
-    friend difference_type operator -(const const_reverse_iterator& lhs, const const_reverse_iterator& rhs)
-    {
-      return distance(lhs.base(), rhs.base());
-    }
-
   protected:
 
     //*************************************************************************
@@ -1208,11 +1228,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-    virtual
-#endif
+      virtual void repair() ETL_OVERRIDE
+#else
       void repair()
-#ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-      ETL_OVERRIDE
 #endif
     {
       ETL_ASSERT(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::circular_buffer_incompatible_type));
@@ -1395,11 +1413,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-    virtual
-#endif
-      void repair()
-#ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/compare.h b/include/etl/compare.h
index 479758d9..63208242 100644
--- a/include/etl/compare.h
+++ b/include/etl/compare.h
@@ -40,40 +40,73 @@ SOFTWARE.
 /// Comparisons only using less than operator
 ///\ingroup utilities
 //*****************************************************************************
-
 namespace etl
 {
   //***************************************************************************
-  /// Defines <=, >, >= in terms of <
-  /// Default
+  /// Defines <=, >, >=, ==, !=, <=> in terms of <
+  /// Default implementation of TLess is etl::less
   //***************************************************************************
   template <typename T, typename TLess = etl::less<T> >
   struct compare
   {
+    enum cmp_result
+    {
+      Less    = -1,
+      Equal   = 0,
+      Greater = 1
+    };
+
     typedef typename etl::parameter_type<T>::type first_argument_type;
     typedef typename etl::parameter_type<T>::type second_argument_type;
-    typedef bool result_type;
 
-    static result_type lt(first_argument_type lhs, second_argument_type rhs)
+    static ETL_CONSTEXPR bool lt(first_argument_type lhs, second_argument_type rhs)
     {
       return TLess()(lhs, rhs);
     }
 
-    static result_type gt(first_argument_type lhs, second_argument_type rhs)
+    static ETL_CONSTEXPR bool gt(first_argument_type lhs, second_argument_type rhs)
     {
       return TLess()(rhs, lhs);
     }
 
-    static result_type lte(first_argument_type lhs, second_argument_type rhs)
+    static ETL_CONSTEXPR bool lte(first_argument_type lhs, second_argument_type rhs)
     {
       return !gt(lhs, rhs);
     }
 
-    static result_type gte(first_argument_type lhs, second_argument_type rhs)
+    static ETL_CONSTEXPR bool gte(first_argument_type lhs, second_argument_type rhs)
     {
       return !lt(lhs, rhs);
     }
+
+    static ETL_CONSTEXPR bool eq(first_argument_type lhs, second_argument_type rhs)
+    {
+      return gte(lhs, rhs) && lte(lhs, rhs);
+    }
+
+    static ETL_CONSTEXPR bool ne(first_argument_type lhs, second_argument_type rhs)
+    {
+      return !eq(lhs, rhs);
+    }
+
+    static ETL_CONSTEXPR cmp_result cmp(first_argument_type lhs, second_argument_type rhs)
+    {
+      return lt(lhs, rhs) ? Less : gt(lhs, rhs) ? Greater : Equal;
+    }
   };
+
+  //***************************************************************************
+  /// Default implementation of TLess is etl::less
+  //***************************************************************************
+#if ETL_USING_CPP11
+  template <typename T, typename TLess = etl::less<T> >
+#else
+  template <typename T, typename TLess>
+#endif
+  ETL_CONSTEXPR14 int three_way_compare(const T& lhs, const T& rhs)
+  {
+    return etl::compare<T>::cmp(lhs, rhs);
+  }
 }
 
 #endif
diff --git a/include/etl/crc.h b/include/etl/crc.h
index eab6d7bc..78ceb552 100644
--- a/include/etl/crc.h
+++ b/include/etl/crc.h
@@ -40,6 +40,8 @@ SOFTWARE.
 #include "crc8_ebu.h"
 #include "crc8_icode.h"
 #include "crc8_itu.h"
+#include "crc8_j1850_zero.h"
+#include "crc8_j1850.h"
 #include "crc8_maxim.h"
 #include "crc8_rohc.h"
 #include "crc8_wcdma.h"
diff --git a/include/etl/crc8_j1850.h b/include/etl/crc8_j1850.h
new file mode 100644
index 00000000..723a2952
--- /dev/null
+++ b/include/etl/crc8_j1850.h
@@ -0,0 +1,79 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2021 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#ifndef ETL_CRC8_J1850_INCLUDED
+#define ETL_CRC8_J1850_INCLUDED
+
+#include "platform.h"
+#include "private/crc_implementation.h"
+
+///\defgroup SAE J1850 8 bit CRC calculation
+///\ingroup crc
+
+namespace etl
+{
+#if ETL_USING_CPP11 && !defined(ETL_CRC_FORCE_CPP03_IMPLEMENTATION)
+  template <size_t Table_Size>
+  using crc8_j1850_t = etl::crc_type<etl::private_crc::crc8_j1850_parameters, Table_Size>;
+#else
+  template <size_t Table_Size>
+  class crc8_j1850_t : public etl::crc_type<etl::private_crc::crc8_j1850_parameters, Table_Size>
+  {
+  public:
+
+    //*************************************************************************
+    /// Default constructor.
+    //*************************************************************************
+    crc8_j1850_t()
+    {
+      this->reset();
+    }
+
+    //*************************************************************************
+    /// Constructor from range.
+    /// \param begin Start of the range.
+    /// \param end   End of the range.
+    //*************************************************************************
+    template<typename TIterator>
+    crc8_j1850_t(TIterator begin, const TIterator end)
+    {
+      this->reset();
+      this->add(begin, end);
+    }
+  };
+#endif
+    
+  typedef etl::crc8_j1850_t<256U> crc8_j1850_t256;
+  typedef etl::crc8_j1850_t<16U>  crc8_j1850_t16;
+  typedef etl::crc8_j1850_t<4U>   crc8_j1850_t4;
+  typedef crc8_j1850_t256         crc8_j1850;
+}
+
+#endif
diff --git a/include/etl/crc8_j1850_zero.h b/include/etl/crc8_j1850_zero.h
new file mode 100644
index 00000000..04bd7b55
--- /dev/null
+++ b/include/etl/crc8_j1850_zero.h
@@ -0,0 +1,79 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2021 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#ifndef ETL_CRC8_J1850_ZERO_INCLUDED
+#define ETL_CRC8_J1850_ZERO_INCLUDED
+
+#include "platform.h"
+#include "private/crc_implementation.h"
+
+///\defgroup SAE J1850 Zero 8 bit CRC calculation
+///\ingroup crc
+
+namespace etl
+{
+#if ETL_USING_CPP11 && !defined(ETL_CRC_FORCE_CPP03_IMPLEMENTATION)
+  template <size_t Table_Size>
+  using crc8_j1850_zero_t = etl::crc_type<etl::private_crc::crc8_j1850_zero_parameters, Table_Size>;
+#else
+  template <size_t Table_Size>
+  class crc8_j1850_zero_t : public etl::crc_type<etl::private_crc::crc8_j1850_zero_parameters, Table_Size>
+  {
+  public:
+
+    //*************************************************************************
+    /// Default constructor.
+    //*************************************************************************
+    crc8_j1850_zero_t()
+    {
+      this->reset();
+    }
+
+    //*************************************************************************
+    /// Constructor from range.
+    /// \param begin Start of the range.
+    /// \param end   End of the range.
+    //*************************************************************************
+    template<typename TIterator>
+    crc8_j1850_zero_t(TIterator begin, const TIterator end)
+    {
+      this->reset();
+      this->add(begin, end);
+    }
+  };
+#endif
+    
+  typedef etl::crc8_j1850_zero_t<256U> crc8_j1850_zero_t256;
+  typedef etl::crc8_j1850_zero_t<16U>  crc8_j1850_zero_t16;
+  typedef etl::crc8_j1850_zero_t<4U>   crc8_j1850_zero_t4;
+  typedef crc8_j1850_zero_t256         crc8_j1850_zero;
+}
+
+#endif
diff --git a/include/etl/cyclic_value.h b/include/etl/cyclic_value.h
index 03f19325..392c7a14 100644
--- a/include/etl/cyclic_value.h
+++ b/include/etl/cyclic_value.h
@@ -49,19 +49,19 @@ namespace etl
   //***************************************************************************
   /// Provides a value that cycles between two limits.
   //***************************************************************************
-  template <typename T, T FIRST = 0, T LAST = 0, bool EtlRuntimeSpecialisation = ((FIRST == 0) && (LAST == 0))>
+  template <typename T, T First = 0, T Last = 0, bool EtlRuntimeSpecialisation = ((First == 0) && (Last == 0))>
   class cyclic_value;
 
   //***************************************************************************
-  /// Provides a value that cycles between two limits.
+  /// Provides a value that cycles between two compile time limits.
   /// Supports incrementing and decrementing.
   ///\tparam T     The type of the variable.
-  ///\tparam FIRST The first value of the range.
-  ///\tparam LAST  The last value of the range.
+  ///\tparam First The first value of the range.
+  ///\tparam Last  The last value of the range.
   ///\ingroup cyclic_value
   //***************************************************************************
-  template <typename T, T FIRST, T LAST>
-  class cyclic_value<T, FIRST, LAST, false>
+  template <typename T, T First, T Last>
+  class cyclic_value<T, First, Last, false>
   {
   public:
 
@@ -70,7 +70,7 @@ namespace etl
     /// The initial value is set to the first value.
     //*************************************************************************
     cyclic_value()
-      : value(FIRST)
+      : value(First)
     {
     }
 
@@ -87,7 +87,7 @@ namespace etl
     //*************************************************************************
     /// Copy constructor.
     //*************************************************************************
-    cyclic_value(const cyclic_value<T, FIRST, LAST>& other)
+    cyclic_value(const cyclic_value<T, First, Last>& other)
       : value(other.value)
     {
     }
@@ -95,7 +95,7 @@ namespace etl
     //*************************************************************************
     /// Assignment operator.
     //*************************************************************************
-    cyclic_value& operator =(const cyclic_value<T, FIRST, LAST>& other)
+    cyclic_value& operator =(const cyclic_value<T, First, Last>& other)
     {
       value = other.value;
 
@@ -104,17 +104,18 @@ namespace etl
 
     //*************************************************************************
     /// Sets the value.
+    /// Truncates to the First/Last range.
     ///\param value The value.
     //*************************************************************************
     void set(T value_)
     {
-      if (value_ > LAST)
+      if (value_ > Last)
       {
-        value_ = LAST;
+        value_ = Last;
       }
-      else if (value_ < FIRST)
+      else if (value_ < First)
       {
-        value_ = FIRST;
+        value_ = First;
       }
 
       value = value_;
@@ -125,7 +126,7 @@ namespace etl
     //*************************************************************************
     void to_first()
     {
-      value = FIRST;
+      value = First;
     }
 
     //*************************************************************************
@@ -133,7 +134,7 @@ namespace etl
     //*************************************************************************
     void to_last()
     {
-      value = LAST;
+      value = Last;
     }
 
     //*************************************************************************
@@ -181,9 +182,9 @@ namespace etl
     //*************************************************************************
     cyclic_value& operator ++()
     {
-      if (value >= LAST) ETL_UNLIKELY
+      if (value >= Last) ETL_UNLIKELY
       {
-        value = FIRST;
+        value = First;
       }
       else
       {
@@ -210,9 +211,9 @@ namespace etl
     //*************************************************************************
     cyclic_value& operator --()
     {
-      if (value <= FIRST) ETL_UNLIKELY
+      if (value <= First) ETL_UNLIKELY
       {
-        value = LAST;
+        value = Last;
       }
       else
       {
@@ -264,23 +265,23 @@ namespace etl
     //*************************************************************************
     /// Gets the first value.
     //*************************************************************************
-    const T first() const
+    static ETL_CONSTEXPR T first()
     {
-      return FIRST;
+      return First;
     }
 
     //*************************************************************************
     /// Gets the last value.
     //*************************************************************************
-    const T last() const
+    static ETL_CONSTEXPR T last()
     {
-      return LAST;
+      return Last;
     }
 
     //*************************************************************************
     /// Swaps the values.
     //*************************************************************************
-    void swap(cyclic_value<T, FIRST, LAST>& other)
+    void swap(cyclic_value<T, First, Last>& other)
     {
       using ETL_OR_STD::swap; // Allow ADL
 
@@ -290,7 +291,7 @@ namespace etl
     //*************************************************************************
     /// Swaps the values.
     //*************************************************************************
-    friend void swap(cyclic_value<T, FIRST, LAST>& lhs, cyclic_value<T, FIRST, LAST>& rhs)
+    friend void swap(cyclic_value<T, First, Last>& lhs, cyclic_value<T, First, Last>& rhs)
     {
       lhs.swap(rhs);
     }
@@ -298,7 +299,7 @@ namespace etl
     //*************************************************************************
     /// Operator ==.
     //*************************************************************************
-    friend bool operator == (const cyclic_value<T, FIRST, LAST>& lhs, const cyclic_value<T, FIRST, LAST>& rhs)
+    friend bool operator == (const cyclic_value<T, First, Last>& lhs, const cyclic_value<T, First, Last>& rhs)
     {
       return lhs.value == rhs.value;
     }
@@ -306,7 +307,7 @@ namespace etl
     //*************************************************************************
     /// Operator !=.
     //*************************************************************************
-    friend bool operator != (const cyclic_value<T, FIRST, LAST>& lhs, const cyclic_value<T, FIRST, LAST>& rhs)
+    friend bool operator != (const cyclic_value<T, First, Last>& lhs, const cyclic_value<T, First, Last>& rhs)
     {
       return !(lhs == rhs);
     }
@@ -317,15 +318,15 @@ namespace etl
   };
 
   //***************************************************************************
-  /// Provides a value that cycles between two limits.
+  /// Provides a value that cycles between two run time limits.
   /// Supports incrementing and decrementing.
   ///\tparam T     The type of the variable.
-  ///\tparam FIRST The first value of the range.
-  ///\tparam LAST  The last value of the range.
+  ///\tparam First The first value of the range.
+  ///\tparam Last  The last value of the range.
   ///\ingroup cyclic_value
   //***************************************************************************
-  template <typename T, T FIRST, T LAST>
-  class cyclic_value<T, FIRST, LAST, true>
+  template <typename T, T First, T Last>
+  class cyclic_value<T, First, Last, true>
   {
   public:
 
@@ -335,9 +336,9 @@ namespace etl
     /// The initial value is set to the first value.
     //*************************************************************************
     cyclic_value()
-      : value(FIRST),
-        first_value(FIRST),
-        last_value(LAST)
+      : value(First)
+      , first_value(First)
+      , last_value(Last)
     {
     }
 
@@ -348,9 +349,9 @@ namespace etl
     ///\param last  The last value in the range.
     //*************************************************************************
     cyclic_value(T first_, T last_)
-      : value(first_),
-        first_value(first_),
-        last_value(last_) 
+      : value(first_)
+      , first_value(first_)
+      , last_value(last_) 
     {
     }
 
@@ -372,9 +373,9 @@ namespace etl
     /// Copy constructor.
     //*************************************************************************
     cyclic_value(const cyclic_value& other)
-      : value(other.value),
-        first_value(other.first_value),
-        last_value(other.last_value)
+      : value(other.value)
+      , first_value(other.first_value)
+      , last_value(other.last_value)
     {
     }
 
@@ -570,7 +571,7 @@ namespace etl
     //*************************************************************************
     /// Swaps the values.
     //*************************************************************************
-    void swap(cyclic_value<T, FIRST, LAST>& other)
+    void swap(cyclic_value<T, First, Last>& other)
     {
       using ETL_OR_STD::swap; // Allow ADL
 
@@ -582,7 +583,7 @@ namespace etl
     //*************************************************************************
     /// Swaps the values.
     //*************************************************************************
-    friend void swap(cyclic_value<T, FIRST, LAST>& lhs, cyclic_value<T, FIRST, LAST>& rhs)
+    friend void swap(cyclic_value<T, First, Last>& lhs, cyclic_value<T, First, Last>& rhs)
     {
       lhs.swap(rhs);
     }
@@ -590,7 +591,7 @@ namespace etl
     //*************************************************************************
     /// Operator ==.
     //*************************************************************************
-    friend bool operator == (const cyclic_value<T, FIRST, LAST>& lhs, const cyclic_value<T, FIRST, LAST>& rhs)
+    friend bool operator == (const cyclic_value<T, First, Last>& lhs, const cyclic_value<T, First, Last>& rhs)
     {
       return (lhs.value       == rhs.value) &&
              (lhs.first_value == rhs.first_value) &&
@@ -600,7 +601,7 @@ namespace etl
     //*************************************************************************
     /// Operator !=.
     //*************************************************************************
-    friend bool operator != (const cyclic_value<T, FIRST, LAST>& lhs, const cyclic_value<T, FIRST, LAST>& rhs)
+    friend bool operator != (const cyclic_value<T, First, Last>& lhs, const cyclic_value<T, First, Last>& rhs)
     {
       return !(lhs == rhs);
     }
diff --git a/include/etl/deque.h b/include/etl/deque.h
index 8a11063e..8e7c3571 100644
--- a/include/etl/deque.h
+++ b/include/etl/deque.h
@@ -41,7 +41,6 @@ SOFTWARE.
 #include "debug_count.h"
 #include "algorithm.h"
 #include "type_traits.h"
-#include "iterator.h"
 #include "placement_new.h"
 #include "initializer_list.h"
 
@@ -258,17 +257,17 @@ namespace etl
 
       //***************************************************
       iterator(const iterator& other)
-        : index(other.index),
-        p_deque(other.p_deque),
-        p_buffer(other.p_buffer)
+        : index(other.index)
+        , p_deque(other.p_deque)
+        , p_buffer(other.p_buffer)
       {
       }
 
       //***************************************************
       iterator& operator =(const iterator& other)
       {
-        index = other.index;
-        p_deque = other.p_deque;
+        index    = other.index;
+        p_deque  = other.p_deque;
         p_buffer = other.p_buffer;
 
         return *this;
@@ -352,6 +351,24 @@ namespace etl
         return &p_buffer[index];
       }
 
+      //***************************************************
+      reference operator [](size_t i)
+      {
+        iterator result(*this);
+        result += i;
+
+        return *result;
+      }
+
+      //***************************************************
+      const_reference operator [](size_t i) const
+      {
+        iterator result(*this);
+        result += i;
+
+        return *result;
+      }
+
       //***************************************************
       friend iterator operator +(const iterator& lhs, difference_type offset)
       {
@@ -360,6 +377,14 @@ namespace etl
         return result;
       }
 
+      //***************************************************
+      friend iterator operator +(difference_type offset, const iterator& lhs)
+      {
+        iterator result(lhs);
+        result += offset;
+        return result;
+      }
+
       //***************************************************
       friend iterator operator -(const iterator& lhs, difference_type offset)
       {
@@ -596,6 +621,15 @@ namespace etl
         return &p_buffer[index];
       }
 
+      //***************************************************
+      reference operator [](size_t i)
+      {
+        iterator result(*this);
+        result += i;
+
+        return *result;
+      }
+
       //***************************************************
       friend const_iterator operator +(const const_iterator& lhs, difference_type offset)
       {
@@ -604,6 +638,14 @@ namespace etl
         return result;
       }
 
+      //***************************************************
+      friend const_iterator operator +(difference_type offset, const const_iterator& lhs)
+      {
+        const_iterator result(lhs);
+        result += offset;
+        return result;
+      }
+
       //***************************************************
       friend const_iterator operator -(const const_iterator& lhs, difference_type offset)
       {
@@ -2054,22 +2096,6 @@ namespace etl
       return distance(rhs, lhs);
     }
 
-    //*************************************************************************
-    /// - operator for reverse_iterator
-    //*************************************************************************
-    friend difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs)
-    {
-      return distance(lhs.base(), rhs.base());
-    }
-
-    //*************************************************************************
-    /// - operator for const_reverse_iterator
-    //*************************************************************************
-    friend difference_type operator -(const const_reverse_iterator& lhs, const const_reverse_iterator& rhs)
-    {
-      return distance(lhs.base(), rhs.base());
-    }
-
     //*************************************************************************
     /// Assignment operator.
     //*************************************************************************
@@ -2483,11 +2509,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_IDEQUE_REPAIR_ENABLE
-      virtual
-#endif
-      void repair()
-#ifdef ETL_IDEQUE_REPAIR_ENABLE
-      ETL_OVERRIDE
+        virtual void repair() ETL_OVERRIDE
+#else
+        void repair()
 #endif
     {
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
diff --git a/include/etl/expected.h b/include/etl/expected.h
index f7a123f4..0c3dd983 100644
--- a/include/etl/expected.h
+++ b/include/etl/expected.h
@@ -38,6 +38,7 @@ SOFTWARE.
 #include "error_handler.h"
 #include "utility.h"
 #include "variant.h"
+#include "initializer_list.h"
 
 namespace etl
 {
@@ -353,6 +354,7 @@ namespace etl
     {
     }
 
+#if ETL_HAS_INITIALIZER_LIST
     //*******************************************
     /// Construct value type from initializser_list and arguments.
     //*******************************************
@@ -361,6 +363,7 @@ namespace etl
       : storage(il, etl::forward<Args>(args)...)
     {
     }
+#endif
 
     //*******************************************
     /// Construct error type from arguments.
@@ -608,17 +611,23 @@ namespace etl
     template <typename... Args>
     ETL_CONSTEXPR14 value_type& emplace(Args&&... args) ETL_NOEXCEPT
     {
-      storage.emplace(etl::forward<Args>(args)...);
+      storage.template emplace<value_type>(etl::forward<Args>(args)...);
+
+      return value();
     }
 
     //*******************************************
     ///
     //*******************************************
+#if ETL_HAS_INITIALIZER_LIST
     template <typename U, typename... Args>
-    ETL_CONSTEXPR14 value_type& emplace(std::initializer_list<U>& il, Args&&... args) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 value_type& emplace(std::initializer_list<U> il, Args&&... args) ETL_NOEXCEPT
     {
-      storage.emplace(il, etl::forward<Args>(args)...);
+      storage.template emplace<value_type>(il, etl::forward<Args>(args)...);
+
+      return value();
     }
+#endif
 #else
     //*******************************************
     ///
diff --git a/include/etl/frame_check_sequence.h b/include/etl/frame_check_sequence.h
index 0311c43a..ec67e1ba 100644
--- a/include/etl/frame_check_sequence.h
+++ b/include/etl/frame_check_sequence.h
@@ -76,7 +76,7 @@ namespace etl
       }
 
       //***********************************
-      add_insert_iterator& operator =(typename TFrame_Check_Sequence::value_type value)
+      add_insert_iterator& operator =(uint8_t value)
       {
         p_fcs->add(value);
         return *this;
diff --git a/include/etl/fsm.h b/include/etl/fsm.h
index 19584a91..04715779 100644
--- a/include/etl/fsm.h
+++ b/include/etl/fsm.h
@@ -158,7 +158,7 @@ namespace etl
   };
 
   //***************************************************************************
-  /// Exception for forbidden state chages.
+  /// Exception for forbidden state changes.
   //***************************************************************************
   class fsm_state_composite_state_change_forbidden : public etl::fsm_exception
   {
@@ -169,6 +169,18 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Exception for message received but not started.
+  //***************************************************************************
+  class fsm_not_started : public etl::fsm_exception
+  {
+  public:
+    fsm_not_started(string_type file_name_, numeric_type line_number_)
+      : etl::fsm_exception(ETL_ERROR_TEXT("fsm:not started", ETL_FSM_FILE_ID"F"), file_name_, line_number_)
+    {
+    }
+  };
+
   namespace private_fsm
   {
     template <typename T = void>
@@ -404,31 +416,38 @@ namespace etl
     //*******************************************
     void receive(const etl::imessage& message) ETL_OVERRIDE
     {
-      etl::fsm_state_id_t next_state_id = p_state->process_event(message);
-
-      if (have_changed_state(next_state_id))
+      if (is_started())
       {
-        ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-        etl::ifsm_state* p_next_state = state_list[next_state_id];
+        etl::fsm_state_id_t next_state_id = p_state->process_event(message);
 
-        do
+        if (have_changed_state(next_state_id))
+        {
+          ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+          etl::ifsm_state* p_next_state = state_list[next_state_id];
+
+          do
+          {
+            p_state->on_exit_state();
+            p_state = p_next_state;
+
+            next_state_id = p_state->on_enter_state();
+
+            if (have_changed_state(next_state_id))
+            {
+              ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+              p_next_state = state_list[next_state_id];
+            }
+          } while (p_next_state != p_state); // Have we changed state again?
+        }
+        else if (is_self_transition(next_state_id))
         {
           p_state->on_exit_state();
-          p_state = p_next_state;
-
-          next_state_id = p_state->on_enter_state();
-
-          if (have_changed_state(next_state_id))
-          {
-            ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-            p_next_state = state_list[next_state_id];
-          }
-        } while (p_next_state != p_state); // Have we changed state again?
+          p_state->on_enter_state();
+        }
       }
-      else if (is_self_transition(next_state_id))
+      else
       {
-        p_state->on_exit_state();
-        p_state->on_enter_state();
+        ETL_ASSERT_FAIL(ETL_ERROR(etl::fsm_not_started));
       }
     }
 
@@ -587,11 +606,11 @@ namespace etl
 
     //********************************************
     template <typename TMessage>
-    bool process_event_type(const etl::imessage& msg, etl::fsm_state_id_t& state_id)
+    bool process_event_type(const etl::imessage& msg, etl::fsm_state_id_t& new_state_id)
     {
       if (TMessage::ID == msg.get_message_id())
       {
-        state_id = static_cast<TDerived*>(this)->on_event(static_cast<const TMessage&>(msg));
+        new_state_id = static_cast<TDerived*>(this)->on_event(static_cast<const TMessage&>(msg));
         return true;
       }
       else
diff --git a/include/etl/functional.h b/include/etl/functional.h
index e6a72ad8..d762506c 100644
--- a/include/etl/functional.h
+++ b/include/etl/functional.h
@@ -32,6 +32,7 @@ SOFTWARE.
 #define ETL_FUNCTIONAL_INCLUDED
 
 #include "platform.h"
+#include "utility.h"
 
 ///\defgroup functional functional
 ///\ingroup utilities
@@ -528,6 +529,73 @@ namespace etl
       return ~lhs;
     }
   };
+
+#if ETL_USING_CPP11
+  namespace private_functional
+  {
+    //***************************************************************************
+    template<typename TReturnType, typename TClassType, typename... TArgs>
+    class mem_fn_impl
+    {
+    public:
+
+      typedef TReturnType(TClassType::* MemberFunctionType)(TArgs...);
+
+      ETL_CONSTEXPR mem_fn_impl(MemberFunctionType member_function_)
+        : member_function(member_function_)
+      {
+      }
+
+      ETL_CONSTEXPR TReturnType operator()(TClassType& instance, TArgs... args) const
+      {
+        return (instance.*member_function)(etl::forward<TArgs>(args)...);
+      }
+
+    private:
+
+      MemberFunctionType member_function;
+    };
+
+    //***************************************************************************
+    template<typename TReturnType, typename TClassType, typename... TArgs>
+    class const_mem_fn_impl
+    {
+    public:
+
+      typedef TReturnType(TClassType::* MemberFunctionType)(TArgs...) const;
+
+      ETL_CONSTEXPR const_mem_fn_impl(MemberFunctionType member_function_)
+        : member_function(member_function_)
+      {
+      }
+
+      ETL_CONSTEXPR TReturnType operator()(const TClassType& instance, TArgs... args) const
+      {
+        return (instance.*member_function)(etl::forward<TArgs>(args)...);
+      }
+
+    private:
+
+      MemberFunctionType member_function;
+    };
+  }
+
+  //***************************************************************************
+  template<typename TReturnType, typename TClassType, typename... TArgs>
+  ETL_CONSTEXPR
+  private_functional::mem_fn_impl<TReturnType, TClassType, TArgs...> mem_fn(TReturnType(TClassType::* member_function)(TArgs...))
+  {
+    return private_functional::mem_fn_impl<TReturnType, TClassType, TArgs...>(member_function);
+  }
+
+  //***************************************************************************
+  template<typename TReturnType, typename TClassType, typename... TArgs>
+  ETL_CONSTEXPR
+  private_functional::const_mem_fn_impl<TReturnType, TClassType, TArgs...> mem_fn(TReturnType(TClassType::* member_function)(TArgs...) const)
+  {
+    return private_functional::const_mem_fn_impl<TReturnType, TClassType, TArgs...>(member_function);
+  }
+#endif
 }
 
 #endif
diff --git a/include/etl/generators/fsm_generator.h b/include/etl/generators/fsm_generator.h
index a59d1fa1..d0e029f7 100644
--- a/include/etl/generators/fsm_generator.h
+++ b/include/etl/generators/fsm_generator.h
@@ -177,7 +177,7 @@ namespace etl
   };
 
   //***************************************************************************
-  /// Exception for forbidden state chages.
+  /// Exception for forbidden state changes.
   //***************************************************************************
   class fsm_state_composite_state_change_forbidden : public etl::fsm_exception
   {
@@ -188,6 +188,18 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Exception for message received but not started.
+  //***************************************************************************
+  class fsm_not_started : public etl::fsm_exception
+  {
+  public:
+    fsm_not_started(string_type file_name_, numeric_type line_number_)
+      : etl::fsm_exception(ETL_ERROR_TEXT("fsm:not started", ETL_FSM_FILE_ID"F"), file_name_, line_number_)
+    {
+    }
+  };
+
   namespace private_fsm
   {
     template <typename T = void>
@@ -430,31 +442,38 @@ namespace etl
     //*******************************************
     void receive(const etl::imessage& message) ETL_OVERRIDE
     {
-      etl::fsm_state_id_t next_state_id = p_state->process_event(message);
-
-      if (have_changed_state(next_state_id))
+      if (is_started())
       {
-        ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-        etl::ifsm_state* p_next_state = state_list[next_state_id];
+        etl::fsm_state_id_t next_state_id = p_state->process_event(message);
 
-        do
+        if (have_changed_state(next_state_id))
+        {
+          ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+          etl::ifsm_state* p_next_state = state_list[next_state_id];
+
+          do
+          {
+            p_state->on_exit_state();
+            p_state = p_next_state;
+
+            next_state_id = p_state->on_enter_state();
+
+            if (have_changed_state(next_state_id))
+            {
+              ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+              p_next_state = state_list[next_state_id];
+            }
+          } while (p_next_state != p_state); // Have we changed state again?
+        }
+        else if (is_self_transition(next_state_id))
         {
           p_state->on_exit_state();
-          p_state = p_next_state;
-
-          next_state_id = p_state->on_enter_state();
-
-          if (have_changed_state(next_state_id))
-          {
-            ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-            p_next_state = state_list[next_state_id];
-          }
-        } while (p_next_state != p_state); // Have we changed state again?
+          p_state->on_enter_state();
+        }
       }
-      else if (is_self_transition(next_state_id))
+      else
       {
-        p_state->on_exit_state();
-        p_state->on_enter_state();
+        ETL_ASSERT_FAIL(ETL_ERROR(etl::fsm_not_started));
       }
     }
 
@@ -613,11 +632,11 @@ namespace etl
 
     //********************************************
     template <typename TMessage>
-    bool process_event_type(const etl::imessage& msg, etl::fsm_state_id_t& state_id)
+    bool process_event_type(const etl::imessage& msg, etl::fsm_state_id_t& new_state_id)
     {
       if (TMessage::ID == msg.get_message_id())
       {
-        state_id = static_cast<TDerived*>(this)->on_event(static_cast<const TMessage&>(msg));
+        new_state_id = static_cast<TDerived*>(this)->on_event(static_cast<const TMessage&>(msg));
         return true;
       }
       else
diff --git a/include/etl/generators/message_packet_generator.h b/include/etl/generators/message_packet_generator.h
index cc3cfab3..595fa12f 100644
--- a/include/etl/generators/message_packet_generator.h
+++ b/include/etl/generators/message_packet_generator.h
@@ -111,7 +111,7 @@ namespace etl
     ///
     //********************************************
 #include "private/diagnostic_uninitialized_push.h"
-    template <typename T>
+    template <typename T, typename = typename etl::enable_if<IsIMessage<T> || IsInMessageList<T>, int>::type>
     explicit message_packet(T&& msg)
       : valid(true)
     {
@@ -133,10 +133,6 @@ namespace etl
       {
         add_new_message_type<T>(etl::forward<T>(msg));
       }
-      else if constexpr (IsMessagePacket<T>)
-      {
-        copy(etl::forward<T>(msg));
-      }
       else
       {
         ETL_STATIC_ASSERT(IsInMessageList<T>, "Message not in packet type list");
@@ -144,6 +140,30 @@ namespace etl
     }
 #include "private/diagnostic_pop.h"
 
+    //**********************************************
+    message_packet(const message_packet& other)
+    {
+      valid = other.is_valid();
+
+      if (valid)
+      {
+        add_new_message(other.get());
+      }
+    }
+
+#if ETL_USING_CPP11
+    //**********************************************
+    message_packet(message_packet&& other)
+    {
+      valid = other.is_valid();
+
+      if (valid)
+      {
+        add_new_message(etl::move(other.get()));
+      }
+    }
+#endif
+
     //**********************************************
     void copy(const message_packet& other)
     {
diff --git a/include/etl/generators/message_router_generator.h b/include/etl/generators/message_router_generator.h
index 32903acf..35d47d70 100644
--- a/include/etl/generators/message_router_generator.h
+++ b/include/etl/generators/message_router_generator.h
@@ -51,7 +51,7 @@ cog.outl("//********************************************************************
 // Note: You will need Python and COG installed.
 //
 // python -m cogapp -d -e -omessage_router.h -DHandlers=<n> message_router_generator.h
-// Where <n> is the number of messages to support.
+// Where <n> is the maximum number of messages to support.
 //
 // e.g.
 // To generate handlers for up to 16 messages...
@@ -212,8 +212,8 @@ namespace etl
     }
 
     //********************************************
-    null_message_router(etl::imessage_router& successor)
-      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor)
+    null_message_router(etl::imessage_router& successor_)
+      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
     {
     }
     
@@ -290,8 +290,8 @@ namespace etl
     }
 
     //********************************************
-    message_producer(etl::imessage_router& successor)
-      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor)
+    message_producer(etl::imessage_router& successor_)
+      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
     {
     }
 
@@ -303,8 +303,8 @@ namespace etl
     }
 
     //********************************************
-    message_producer(etl::message_router_id_t id_, etl::imessage_router& successor)
-      : imessage_router(id_, successor)
+    message_producer(etl::message_router_id_t id_, etl::imessage_router& successor_)
+      : imessage_router(id_, successor_)
     {
       ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
     }
@@ -354,11 +354,22 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Is T ultimately derived from etl::imessage_router?
+  //***************************************************************************
+  template <typename T>
+  struct is_message_router : public etl::bool_constant<etl::is_base_of<etl::imessage_router, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
   //***************************************************************************
   /// Send a message to a router.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  const etl::imessage&  message)
+  template <typename TRouter, typename TMessage>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    send_message(TRouter&        destination,
+                 const TMessage& message)
   {
     destination.receive(message);
   }
@@ -366,8 +377,11 @@ namespace etl
   //***************************************************************************
   /// Send a shared message to a router.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::shared_message message)
+  template <typename TRouter>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    send_message(TRouter&            destination,
+                 etl::shared_message message)
   {
     destination.receive(message);
   }
@@ -375,9 +389,12 @@ namespace etl
   //***************************************************************************
   /// Send a message to a router with a particular id.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::message_router_id_t id,
-                                  const etl::imessage& message)
+  template <typename TRouter, typename TMessage>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    send_message(TRouter&                 destination,
+                 etl::message_router_id_t id,
+                 const TMessage&          message)
   {
     destination.receive(id, message);
   }
@@ -385,9 +402,12 @@ namespace etl
   //***************************************************************************
   /// Send a shared message to a router with a particular id.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::message_router_id_t id,
-                                  etl::shared_message message)
+  template <typename TRouter>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    send_message(TRouter&                 destination,
+                 etl::message_router_id_t id,
+                 etl::shared_message      message)
   {
     destination.receive(id, message);
   }
diff --git a/include/etl/generators/type_traits_generator.h b/include/etl/generators/type_traits_generator.h
index d2cf8ce6..d8c1ee60 100644
--- a/include/etl/generators/type_traits_generator.h
+++ b/include/etl/generators/type_traits_generator.h
@@ -74,7 +74,7 @@ cog.outl("//********************************************************************
 
 ///\defgroup type_traits type_traits
 /// A set of type traits definitions.
-/// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined.
+/// Derived from either the standard or alternate definitions, dependent on whether or not ETL_NO_STL is defined.
 /// \ingroup utilities
 
 #if ETL_USING_STL && ETL_USING_CPP11
@@ -2077,6 +2077,21 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
+#if ETL_USING_CPP11
+  //*********************************************
+  // is_default_constructible
+  template<typename T, typename = void>
+  struct is_default_constructible : etl::false_type { };
+
+  template<typename T>
+  struct is_default_constructible<T, etl::void_t<decltype(T())>> : etl::true_type { };
+#else
+  template <typename T>
+  struct is_default_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
+  {
+  };
+#endif
+
 #if ETL_USING_CPP17
 
   template <typename T1, typename T2>
@@ -2088,6 +2103,9 @@ typedef integral_constant<bool, true>  true_type;
   template<typename T, typename... TArgs>
   inline constexpr bool is_constructible_v = etl::is_constructible<T, TArgs...>::value;
 
+  template<typename T, typename... TArgs>
+  inline constexpr bool is_default_constructible_v = etl::is_default_constructible<T, TArgs...>::value;
+
   template<typename T>
   inline constexpr bool is_copy_constructible_v = etl::is_copy_constructible<T>::value;
 
diff --git a/include/etl/hfsm.h b/include/etl/hfsm.h
index d61ac70b..8afe94f4 100644
--- a/include/etl/hfsm.h
+++ b/include/etl/hfsm.h
@@ -55,7 +55,7 @@ namespace etl
     /// Can only be called once.
     /// Subsequent calls will do nothing.
     ///\param call_on_enter_state If true will call on_enter_state() for the first state. Default = true.
-    /// If the first state has child states then they will be recersively entered.
+    /// If the first state has child states then they will be recursively entered.
     //*******************************************
     void start(bool call_on_enter_state = true) ETL_OVERRIDE
     {
@@ -98,30 +98,37 @@ namespace etl
     //*******************************************
     void receive(const etl::imessage& message) ETL_OVERRIDE
     {
-      etl::fsm_state_id_t next_state_id = p_state->process_event(message);
-
-      if (next_state_id != ifsm_state::No_State_Change)
+      if (is_started())
       {
-        ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-        etl::ifsm_state* p_next_state = state_list[next_state_id];
+        etl::fsm_state_id_t next_state_id = p_state->process_event(message);
 
-        // Have we changed state?
-        if (p_next_state != p_state)
+        if (next_state_id != ifsm_state::No_State_Change)
         {
-          etl::ifsm_state* p_root = common_ancestor(p_state, p_next_state);
-          do_exits(p_root, p_state);
+          ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+          etl::ifsm_state* p_next_state = state_list[next_state_id];
 
-          p_state = p_next_state;
-
-          next_state_id = do_enters(p_root, p_next_state, true);
-
-          if (next_state_id != ifsm_state::No_State_Change)
+          // Have we changed state?
+          if (p_next_state != p_state)
           {
-            ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-            p_state = state_list[next_state_id];
+            etl::ifsm_state* p_root = common_ancestor(p_state, p_next_state);
+            do_exits(p_root, p_state);
+
+            p_state = p_next_state;
+
+            next_state_id = do_enters(p_root, p_next_state, true);
+
+            if (next_state_id != ifsm_state::No_State_Change)
+            {
+              ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+              p_state = state_list[next_state_id];
+            }
           }
         }
       }
+      else
+      {
+        ETL_ASSERT_FAIL(ETL_ERROR(etl::fsm_not_started));
+      }
     }
 
   private:
diff --git a/include/etl/intrusive_forward_list.h b/include/etl/intrusive_forward_list.h
index 665d42e2..a38cf43e 100644
--- a/include/etl/intrusive_forward_list.h
+++ b/include/etl/intrusive_forward_list.h
@@ -209,7 +209,7 @@ namespace etl
 #if defined(ETL_CHECK_PUSH_POP)
       ETL_ASSERT_OR_RETURN(!empty(), ETL_ERROR(intrusive_forward_list_empty));
 #endif
-      remove_link_after(start);
+      disconnect_link_after(start);
     }
 
     //*************************************************************************
@@ -297,7 +297,7 @@ namespace etl
     //*************************************************************************
     /// Remove a link.
     //*************************************************************************
-    void remove_link_after(link_type& link)
+    void disconnect_link_after(link_type& link)
     {
       link_type* p_next = link.etl_next;
 
@@ -333,6 +333,89 @@ namespace etl
       start.etl_next = &terminator;
       current_size = 0;
     }
+
+    //*************************************************************************
+    /// Tests if the link is in this list.
+    /// Returns the previous link to it, if found, otherwise ETL_NULLPTR.
+    //*************************************************************************
+    link_type* is_link_in_list(link_type& search_link)
+    {
+      link_type* p_link     = start.etl_next;
+      link_type* p_previous = &start;
+
+      while (p_link != ETL_NULLPTR)
+      {
+        if (&search_link == p_link)
+        {
+          return p_previous;
+        }
+
+        p_previous = p_link;
+
+        if (p_link != ETL_NULLPTR)
+        {
+          p_link = p_link->link_type::etl_next;
+        }
+      }
+
+      return ETL_NULLPTR;
+    }
+
+    //*************************************************************************
+    /// Remove the specified node from the list.
+    /// Returns ETL_NULLPTR if the link was not in this list.
+    /// Returns the next 
+    //*************************************************************************
+    link_type* remove_link(link_type& link)
+    {
+      link_type* result = ETL_NULLPTR;
+
+      link_type* p_previous = is_link_in_list(link);
+
+      if (p_previous != ETL_NULLPTR)
+      {
+        link_type* p_next = link.etl_next;
+
+        disconnect_link_after(*p_previous);
+
+        if (p_next != &this->terminator)
+        {
+          result = p_next;
+        }
+      }
+
+      return result;
+    }
+
+    //*************************************************************************
+    /// Remove a range of elements.
+    //*************************************************************************
+    link_type* remove_link_range_after(link_type* p_first, link_type* p_last)
+    {
+      link_type* p_after = p_first->etl_next;
+
+      // Join the ends.
+      etl::link<link_type>(p_first, p_last);
+
+      // Unlink the erased range.
+      link_type* p_unlink = p_after;
+
+      while (p_unlink != p_last)
+      {
+        link_type* p_next = p_unlink->etl_next;
+        p_unlink->clear();
+        p_unlink = p_next;
+      }
+
+      if (p_after == &this->terminator)
+      {
+        return ETL_NULLPTR;
+      }
+      else
+      {
+        return p_last;
+      }
+    }
   };
 
   template <typename TLink>
@@ -361,6 +444,8 @@ namespace etl
 
     typedef intrusive_forward_list<TValue, TLink> list_type;
 
+    typedef TValue node_type;
+
     //*************************************************************************
     /// iterator.
     //*************************************************************************
@@ -404,7 +489,9 @@ namespace etl
 
       reference operator *() const
       {
+#include "etl/private/diagnostic_null_dereference_push.h"
         return *static_cast<pointer>(p_value);
+#include "etl/private/diagnostic_pop.h"
       }
 
       pointer operator &() const
@@ -662,7 +749,7 @@ namespace etl
         if (next != end())
         {
           ++next;
-          this->remove_link_after(*position.p_value);
+          this->disconnect_link_after(*position.p_value);
         }
       }
 
@@ -680,22 +767,9 @@ namespace etl
 
         link_type* p_first = first.p_value;
         link_type* p_last  = last.p_value;
-        link_type* p_after = p_first->etl_next;
-        
-        // Join the ends.
-        etl::link<link_type>(p_first, p_last);
+        link_type* p_after = this->remove_link_range_after(p_first, p_last);
 
-        // Unlink the erased range.
-        link_type* p_unlink = p_after;
-
-        while (p_unlink != p_last)
-        {
-          link_type* p_next = p_unlink->etl_next;
-          p_unlink->clear();
-          p_unlink = p_next;
-        }
-
-        if (p_after == &this->terminator)
+        if (p_after == ETL_NULLPTR)
         {
           return end();
         }
@@ -710,6 +784,14 @@ namespace etl
       }
     }
 
+    //*************************************************************************
+    /// Erases the specified node.
+    //*************************************************************************
+    node_type* erase(node_type& node)
+    {
+      return static_cast<node_type*>(this->remove_link(node));
+    }
+
     //*************************************************************************
     /// Removes all but the one element from every consecutive group of equal
     /// elements in the container.
@@ -730,7 +812,7 @@ namespace etl
         // Is this value the same as the last?
         if (isEqual(*static_cast<pointer>(current), *static_cast<pointer>(last)))
         {
-          this->remove_link_after(*last);
+          this->disconnect_link_after(*last);
         }
         else
         {
diff --git a/include/etl/intrusive_list.h b/include/etl/intrusive_list.h
index 4a48f83e..58c976e8 100644
--- a/include/etl/intrusive_list.h
+++ b/include/etl/intrusive_list.h
@@ -175,7 +175,7 @@ namespace etl
 #if defined(ETL_CHECK_PUSH_POP)
       ETL_ASSERT(!empty(), ETL_ERROR(intrusive_list_empty));
 #endif
-      remove_link(get_head());
+      disconnect_link(get_head());
     }
 
     //*************************************************************************
@@ -196,7 +196,7 @@ namespace etl
 #if defined(ETL_CHECK_PUSH_POP)
       ETL_ASSERT(!empty(), ETL_ERROR(intrusive_list_empty));
 #endif
-      remove_link(get_tail());
+      disconnect_link(get_tail());
     }
 
     //*************************************************************************
@@ -320,7 +320,7 @@ namespace etl
     //*************************************************************************
     /// Remove a link.
     //*************************************************************************
-    void remove_link(link_type& link)
+    void disconnect_link(link_type& link)
     {
       etl::unlink<link_type>(link);
       --current_size;
@@ -329,7 +329,7 @@ namespace etl
     //*************************************************************************
     /// Remove a link.
     //*************************************************************************
-    void remove_link(link_type* link)
+    void disconnect_link(link_type* link)
     {
       etl::unlink<link_type>(*link);
       --current_size;
@@ -375,6 +375,74 @@ namespace etl
       etl::link(terminal_link, terminal_link);
       current_size = 0;
     }
+
+    //*************************************************************************
+    /// Tests if the link is in this list.
+    //*************************************************************************
+    bool is_link_in_list(link_type& search_link) const
+    {
+      link_type* p_link = terminal_link.link_type::etl_next;
+
+      while (p_link != &terminal_link)
+      {
+        if (&search_link == p_link)
+        {
+          return true;
+        }
+
+        p_link = p_link->link_type::etl_next;
+      }
+
+      return false;
+    }
+
+    //*************************************************************************
+    /// Remove the specified node from the list.
+    /// Returns ETL_NULLPTR if the link was not in this list or was the last in the list.
+    //*************************************************************************
+    link_type* remove_link(link_type& link)
+    {
+      link_type* result = ETL_NULLPTR;
+
+      if (is_link_in_list(link))
+      {
+        link_type* p_next = link.etl_next;
+
+        disconnect_link(link);
+
+        if (p_next != &terminal_link)
+        {
+          result = p_next;
+        }
+      }
+
+      return result;
+    }
+
+    //*************************************************************************
+    /// Removes a range of links.
+    //*************************************************************************
+    link_type* remove_link_range(link_type* p_first, link_type* p_last)
+    {
+      // Join the ends.
+      etl::link<link_type>(p_first->etl_previous, p_last);
+
+      while (p_first != p_last)
+      {
+        link_type* p_next = p_first->etl_next;
+        p_first->clear();
+        p_first = p_next;
+      }
+
+      if (p_last == &terminal_link)
+      {
+        return ETL_NULLPTR;
+      }
+      else
+      {
+        return p_last;
+      }
+    }
   };
 
   //***************************************************************************
@@ -392,6 +460,8 @@ namespace etl
 
     typedef intrusive_list<TValue, TLink> list_type;
 
+    typedef TValue node_type;
+
     // STL style typedefs.
     typedef TValue            value_type;
     typedef value_type*       pointer;
@@ -458,7 +528,9 @@ namespace etl
 
       reference operator *() const
       {
+#include "etl/private/diagnostic_null_dereference_push.h"
         return *static_cast<pointer>(p_value);
+#include "etl/private/diagnostic_pop.h"
       }
 
       pointer operator &() const
@@ -724,7 +796,7 @@ namespace etl
       iterator next(position);
       ++next;
 
-      this->remove_link(*position.p_value);
+      this->disconnect_link(*position.p_value);
 
       return next;
     }
@@ -737,7 +809,7 @@ namespace etl
       iterator next(position);
       ++next;
 
-      this->remove_link(*position.p_value);
+      this->disconnect_link(*position.p_value);
 
       return next;
     }
@@ -756,17 +828,9 @@ namespace etl
 
       this->current_size -= etl::distance(first, last);
 
-      // Join the ends.
-      etl::link<link_type>(p_first->etl_previous, p_last);
+      p_last = this->remove_link_range(p_first, p_last);
 
-      while (p_first != p_last)
-      {
-        link_type* p_next = p_first->etl_next;
-        p_first->clear();
-        p_first = p_next;
-      }
-
-      if (p_last == &this->terminal_link)
+      if (p_last == ETL_NULLPTR)
       {
         return end();
       }
@@ -776,6 +840,14 @@ namespace etl
       }
     }
 
+    //*************************************************************************
+    /// Erases the specified node.
+    //*************************************************************************
+    node_type* erase(node_type& node)
+    {
+      return static_cast<node_type*>(this->remove_link(node));
+    }
+
     //*************************************************************************
     /// Removes all but the one element from every consecutive group of equal
     /// elements in the container.
diff --git a/include/etl/iterator.h b/include/etl/iterator.h
index ab19db39..80535132 100644
--- a/include/etl/iterator.h
+++ b/include/etl/iterator.h
@@ -583,36 +583,25 @@ namespace etl
   //***************************************************************************
 
   //***************************************************************************
-  ///\brief  Turns assignment into insertion.
-  ///
-  /// These are output iterators, constructed from a container-of-T.
-  /// Assigning a T to the iterator appends it to the container using push_back.
-  ///
-  /// @tparam TContainer
+  /// Turns assignment into push_back
   //***************************************************************************
   template <typename TContainer>
   class back_insert_iterator : public etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
   {
   public:
 
-    /// A nested typedef for the type of whatever container you used.
     typedef TContainer container_type;
 
-    /// The only way to create this %iterator is with a container.
+    //***************************************************************************
+    /// Constructor
+    //***************************************************************************
     explicit ETL_CONSTEXPR14 back_insert_iterator(TContainer& c)
       : container(etl::addressof(c))
     {
     }
 
     //***************************************************************************
-    /// This kind of %iterator doesn't really have a @a position in the
-    /// container (you can think of the position as being permanently at
-    /// the end, if you like).  Assigning a value to the %iterator will
-    /// always append the value to the end of the container.
-    ///
-    /// @param value An instance of whatever type container_type::const_reference is;
-    ///              presumably a reference-to-const T for container<T>.
-    /// @return This %iterator, for chained operations.
+    /// Assignment operator
     //***************************************************************************
     ETL_CONSTEXPR14 back_insert_iterator& operator =(const typename TContainer::value_type& value)
     {
@@ -635,7 +624,6 @@ namespace etl
 
     //***************************************************************************
     /// Dereference operator.
-    /// Simply returns *this.
     //***************************************************************************
     ETL_NODISCARD ETL_CONSTEXPR14 back_insert_iterator& operator *()
     {
@@ -644,7 +632,6 @@ namespace etl
 
     //***************************************************************************
     /// Pre-increment operator.
-    /// Simply returns *this.  (This %iterator does not @a move.)
     //***************************************************************************
     ETL_CONSTEXPR14 back_insert_iterator& operator ++()
     {
@@ -653,7 +640,6 @@ namespace etl
 
     //***************************************************************************
     /// Post-increment operator.
-    /// Simply returns *this.  (This %iterator does not @a move.)
     //***************************************************************************
     ETL_CONSTEXPR14 back_insert_iterator operator ++(int)
     {
@@ -666,15 +652,7 @@ namespace etl
   };
 
   //***************************************************************************
-  /// This wrapper function helps in creating back_insert_iterator instances.
-  /// Typing the name of the %iterator requires knowing the precise full
-  /// type of the container, which can be tedious and impedes generic
-  /// programming.  Using this function lets you take advantage of automatic
-  /// template parameter deduction, making the compiler match the correct types for you.
-  ///
-  /// @tparam TContainer The container type.
-  /// @param container A container of arbitrary type.
-  /// @return An instance of back_insert_iterator working on @p container.
+  /// Creates a back_insert_iterator from a container.
   //***************************************************************************
   template <typename TContainer>
   ETL_NODISCARD 
@@ -689,28 +667,17 @@ namespace etl
   //***************************************************************************
 
   //***************************************************************************
-  ///\brief Turns assignment into insertion.
-  ///
-  /// These are output iterators, constructed from a container-of-T.
-  /// Assigning a T to the iterator prepends it to the container using
-  /// push_front.
-  ///
-  /// Tip:  Using the front_inserter function to create these iterators can
-  /// save typing.
-  ///
-  ///\tparam TContainer The container type.
+  /// Turns assignment into a push_front.
   //***************************************************************************
   template <typename TContainer>
   class front_insert_iterator : public etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
   {
   public:
 
-    /// A nested typedef for the type of whatever container you used.
     typedef TContainer container_type;
 
     //***************************************************************************
     /// Constructor
-    /// The only way to create this %iterator is with a container.
     //***************************************************************************
     explicit ETL_CONSTEXPR14 front_insert_iterator(TContainer& c)
       : container(etl::addressof(c))
@@ -718,15 +685,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// This kind of %iterator doesn't really have a @a position in the
-    /// container (you can think of the position as being permanently at
-    /// the front, if you like).  Assigning a value to the %iterator will
-    /// always prepend the value to the front of the container.
-    ///
-    /// @param  value  An instance of whatever type
-    ///                container_type::const_reference is; presumably a
-    ///                reference-to-const T for container<T>.
-    /// @return  This %iterator, for chained operations.
+    /// Assignment operator
     //***************************************************************************
     ETL_CONSTEXPR14 front_insert_iterator& operator =(const typename TContainer::value_type& value)
     {
@@ -747,7 +706,6 @@ namespace etl
 
     //***************************************************************************
     /// Dereference operator.
-    /// Simply returns *this.
     //***************************************************************************
     ETL_NODISCARD ETL_CONSTEXPR14 front_insert_iterator& operator *()
     {
@@ -756,7 +714,6 @@ namespace etl
 
     //***************************************************************************
     /// Pre-increment operator.
-    /// Simply returns *this.  (This %iterator does not @a move.)
     //***************************************************************************
     ETL_CONSTEXPR14 front_insert_iterator& operator ++()
     {
@@ -765,7 +722,6 @@ namespace etl
 
     //***************************************************************************
     /// Post-increment operator.
-    /// Simply returns *this.  (This %iterator does not @a move.)
     //***************************************************************************
     ETL_CONSTEXPR14 front_insert_iterator operator ++(int)
     {
@@ -778,16 +734,7 @@ namespace etl
   };
 
   //***************************************************************************
-  /// This wrapper function helps in creating front_insert_iterator instances.
-  /// Typing the name of the %iterator requires knowing the precise full
-  /// type of the container, which can be tedious and impedes generic
-  /// programming.  Using this function lets you take advantage of automatic
-  /// template parameter deduction, making the compiler match the correct
-  /// types for you.
-  ///
-  ///\tparam TContainer The container type.
-  ///\param container A container of arbitrary type.
-  ///\return An instance of front_insert_iterator working on @p x.
+  /// Creates a front_insert_iterator from a container.
   //***************************************************************************
   template <typename TContainer>
   ETL_NODISCARD
@@ -797,6 +744,90 @@ namespace etl
     return etl::front_insert_iterator<TContainer>(container);
   }
 
+  //***************************************************************************
+  // push_insert_iterator
+  //***************************************************************************
+
+  //***************************************************************************
+  /// Turns assignment into a push.
+  //***************************************************************************
+  template <typename TContainer>
+  class push_insert_iterator : public etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
+  {
+  public:
+
+    typedef TContainer container_type;
+
+    //***************************************************************************
+    /// Constructor
+    //***************************************************************************
+    explicit ETL_CONSTEXPR14 push_insert_iterator(TContainer& c)
+      : container(etl::addressof(c))
+    {
+    }
+
+    //***************************************************************************
+    /// Assignment operator
+    //***************************************************************************
+    ETL_CONSTEXPR14 push_insert_iterator& operator =(const typename TContainer::value_type& value)
+    {
+      container->push(value);
+
+      return (*this);
+    }
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Move assignment operator.
+    //***************************************************************************
+    ETL_CONSTEXPR14 push_insert_iterator& operator =(typename TContainer::value_type&& value)
+    {
+      container->push(etl::move(value));
+
+      return (*this);
+    }
+#endif  // ETL_USING_CPP11
+
+    //***************************************************************************
+    /// Dereference operator.
+    //***************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 push_insert_iterator& operator *()
+    {
+      return (*this);
+    }
+
+    //***************************************************************************
+    /// Pre-increment operator.
+    //***************************************************************************
+    ETL_CONSTEXPR14 push_insert_iterator& operator ++()
+    {
+      return (*this);
+    }
+
+    //***************************************************************************
+    /// Post-increment operator.
+    //***************************************************************************
+    ETL_CONSTEXPR14 push_insert_iterator operator ++(int)
+    {
+      return (*this);
+    }
+
+  protected:
+
+    TContainer* container;
+  };
+
+  //***************************************************************************
+  /// Creates a push_insert_iterator from a container.
+  //***************************************************************************
+  template <typename TContainer>
+  ETL_NODISCARD
+    ETL_CONSTEXPR14
+    etl::push_insert_iterator<TContainer> push_inserter(TContainer& container)
+  {
+    return etl::push_insert_iterator<TContainer>(container);
+  }
+
   //***************************************************************************
   // Helper templates.
   //***************************************************************************
diff --git a/include/etl/limits.h b/include/etl/limits.h
index d64f6c57..ac31ca6b 100644
--- a/include/etl/limits.h
+++ b/include/etl/limits.h
@@ -80,19 +80,19 @@ SOFTWARE.
 
 #if defined(ETL_NO_CPP_NAN_SUPPORT)
   #if defined(NAN)
-  #include "etl/private/diagnostic_useless_cast_push.h"
+  #include "private/diagnostic_useless_cast_push.h"
     #define ETL_NANF    NAN
     #define ETL_NAN     static_cast<double>(NAN)
     #define ETL_NANL    static_cast<long double>(NAN)
     #define ETL_HAS_NAN true
-  #include "etl/private/diagnostic_pop.h"
+  #include "private/diagnostic_pop.h"
   #else
-  #include "etl/private/diagnostic_useless_cast_push.h"
+  #include "private/diagnostic_useless_cast_push.h"
     #define ETL_NANF HUGE_VALF    
     #define ETL_NAN  HUGE_VAL
     #define ETL_NANL HUGE_VALL
     #define ETL_HAS_NAN false
-  #include "etl/private/diagnostic_pop.h"
+  #include "private/diagnostic_pop.h"
   #endif
 #else
   #define ETL_NANF    nanf("")
diff --git a/include/etl/list.h b/include/etl/list.h
index 07e51693..eefedf83 100644
--- a/include/etl/list.h
+++ b/include/etl/list.h
@@ -43,7 +43,6 @@ SOFTWARE.
 #include "type_traits.h"
 #include "algorithm.h"
 #include "memory.h"
-#include "iterator.h"
 #include "static_assert.h"
 #include "parameter_type.h"
 #include "placement_new.h"
diff --git a/include/etl/map.h b/include/etl/map.h
index ce81317d..88449df9 100644
--- a/include/etl/map.h
+++ b/include/etl/map.h
@@ -1496,10 +1496,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(const_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new (&node.value) value_type(value);
+      Data_Node* node = allocate_data_node();
+      ::new (&node->value) value_type(value);
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
     //*************************************************************************
@@ -1507,12 +1507,12 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node_with_key(const_key_reference key)
     {
-      Data_Node& node = allocate_data_node();
+      Data_Node* node = allocate_data_node();
 
-      ::new ((void*)etl::addressof(node.value.first))  key_type(key);
-      ::new ((void*)etl::addressof(node.value.second)) mapped_type();
+      ::new ((void*)etl::addressof(node->value.first))  key_type(key);
+      ::new ((void*)etl::addressof(node->value.second)) mapped_type();
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #if ETL_USING_CPP11
@@ -1521,10 +1521,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(rvalue_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new (&node.value) value_type(etl::move(value));
+      Data_Node* node = allocate_data_node();
+      ::new (&node->value) value_type(etl::move(value));
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
     //*************************************************************************
@@ -1532,12 +1532,12 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node_with_key(rvalue_key_reference key)
     {
-      Data_Node& node = allocate_data_node();
+      Data_Node* node = allocate_data_node();
 
-      ::new ((void*)etl::addressof(node.value.first))  key_type(etl::move(key));
-      ::new ((void*)etl::addressof(node.value.second)) mapped_type();
+      ::new ((void*)etl::addressof(node->value.first))  key_type(etl::move(key));
+      ::new ((void*)etl::addressof(node->value.second)) mapped_type();
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #endif
@@ -1545,10 +1545,10 @@ namespace etl
     //*************************************************************************
     /// Create a Data_Node.
     //*************************************************************************
-    Data_Node& allocate_data_node()
+    Data_Node* allocate_data_node()
     {
       Data_Node* (etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
-      return *(p_node_pool->*func)();
+      return (p_node_pool->*func)();
     }
 
     //*************************************************************************
diff --git a/include/etl/memory.h b/include/etl/memory.h
index c4eb8fa9..1abcf638 100644
--- a/include/etl/memory.h
+++ b/include/etl/memory.h
@@ -1424,7 +1424,10 @@ namespace etl
     //*********************************
     unique_ptr&	operator =(std::nullptr_t) ETL_NOEXCEPT
     {
-      reset(nullptr);
+      if (p)
+      {
+        reset(nullptr);
+      }
 
       return *this;
     }
@@ -1432,7 +1435,10 @@ namespace etl
     //*********************************
     unique_ptr&	operator =(void*) ETL_NOEXCEPT
     {
-      reset(NULL);
+      if (p)
+      {
+        reset(NULL);
+      }
 
       return *this;
     }
diff --git a/include/etl/message.h b/include/etl/message.h
index 22a802e6..9c664abc 100644
--- a/include/etl/message.h
+++ b/include/etl/message.h
@@ -62,6 +62,8 @@ namespace etl
     }
   };
 
+  class message_tag {};
+
 #if ETL_HAS_VIRTUAL_MESSAGES
   //***************************************************************************
   /// Message interface.
@@ -85,10 +87,14 @@ namespace etl
   /// Virtual.
   //***************************************************************************
   template <etl::message_id_t ID_, typename TBase = etl::imessage>
-  class message : public TBase
+  class message : public TBase, public etl::message_tag
   {
   public:
 
+    ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TBase>::value), "TBase is not derived from etl::imessage");
+
+    typedef TBase base_type;
+
     //***********************************
     ETL_NODISCARD virtual etl::message_id_t get_message_id() const ETL_NOEXCEPT ETL_OVERRIDE
     {
@@ -149,12 +155,14 @@ namespace etl
   /// Non-virtual.
   //***************************************************************************
   template <etl::message_id_t ID_, typename TBase = etl::imessage>
-  class message : public TBase
+  class message : public TBase, public etl::message_tag
   {
   public:
 
     ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TBase>::value), "TBase is not derived from etl::imessage");
 
+    typedef TBase base_type;
+
     //***********************************
     message() ETL_NOEXCEPT
       : TBase(ID)
@@ -183,6 +191,78 @@ namespace etl
   //***************************************************************************
   template <etl::message_id_t ID_, typename TBase>
   ETL_CONSTANT etl::message_id_t etl::message<ID_, TBase>::ID;
+
+  //***************************************************************************
+  /// Is T an etl::imessage?
+  //***************************************************************************
+  template <typename T>
+  struct is_imessage : public etl::bool_constant<etl::is_same<etl::imessage, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
+  //***************************************************************************
+  /// Is T ultimately derived from etl::imessage?
+  //***************************************************************************
+  template <typename T>
+  struct is_message : public etl::bool_constant<etl::is_base_of<etl::imessage, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
+  //***************************************************************************
+  /// Is T an etl::message<> or derived from etl::message<>
+  //***************************************************************************
+  template <typename T>
+  struct is_message_type : public etl::bool_constant<etl::is_base_of<etl::message_tag, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
+  //***************************************************************************
+  /// Is T a base of etl::message<T>
+  //***************************************************************************
+  template <typename T>
+  struct is_message_base : public etl::bool_constant<etl::is_message<T>::value && !etl::is_message_type<T>::value>
+  {
+  };
+
+  //***************************************************************************
+  /// Is T a user defined base of etl::message<T> and not an etl::imessage
+  //***************************************************************************
+  template <typename T>
+  struct is_user_message_base : public etl::bool_constant<etl::is_message_base<T>::value && !etl::is_imessage<T>::value>
+  {
+  };
+
+#if ETL_USING_CPP17
+  //***************************************************************************
+  /// Is T an etl::imessage?
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_imessage_v = is_imessage<T>::value;
+
+  //***************************************************************************
+  /// Is T ultimately derived from etl::imessage?
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_message_v = is_message<T>::value;
+
+  //***************************************************************************
+  /// Is T derived from etl::message<>
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_message_type_v = is_message_type<T>::value;
+
+  //***************************************************************************
+  /// Is T a base of etl::message<T>
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_message_base_v = is_message_base<T>::value;
+
+  //***************************************************************************
+  /// Is T a user defined base of etl::message<T>
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_user_message_base_v = is_user_message_base<T>::value;
+#endif
 }
 
 #endif
diff --git a/include/etl/message_broker.h b/include/etl/message_broker.h
index ad99cb3f..a8ce0ab5 100644
--- a/include/etl/message_broker.h
+++ b/include/etl/message_broker.h
@@ -228,9 +228,7 @@ namespace etl
       // Always pass the message on to the successor.
       if (has_successor())
       {
-        etl::imessage_router& successor = get_successor();
-
-        successor.receive(destination_router_id, msg);
+        get_successor().receive(destination_router_id, msg);
       }
     }
 
@@ -276,11 +274,48 @@ namespace etl
     using imessage_router::accepts;
 
     //*******************************************
-    /// Message brokers accept all messages.
+    /// Message brokers accept messages determined
+    /// by the subscribed routers.
     //*******************************************
-    virtual bool accepts(etl::message_id_t) const ETL_OVERRIDE
+    virtual bool accepts(etl::message_id_t id) const ETL_OVERRIDE
     {
-      return true;
+      if (!empty())
+      {
+        // Scan the subscription lists.
+        subscription* sub = static_cast<subscription*>(head.get_next());
+
+        while (sub != ETL_NULLPTR)
+        {
+          message_id_span_t message_ids = sub->message_id_list();
+
+          message_id_span_t::iterator itr = etl::find(message_ids.begin(), message_ids.end(), id);
+
+          if (itr != message_ids.end())
+          {
+            etl::imessage_router* router = sub->get_router();
+
+            if (router->accepts(id))
+            {
+              return true;
+            }
+          }
+
+          sub = sub->next_subscription();
+        }
+      }
+
+      // Check any successor.
+      if (has_successor())
+      {
+        if (get_successor().accepts(id))
+        {
+          return true;
+        }
+      }
+
+      return false;
+
+      //return true;
     }
 
     //*******************************************
diff --git a/include/etl/message_bus.h b/include/etl/message_bus.h
index 3ab24dba..1d698e78 100644
--- a/include/etl/message_bus.h
+++ b/include/etl/message_bus.h
@@ -227,11 +227,9 @@ namespace etl
 
       if (has_successor())
       {
-        etl::imessage_router& successor = get_successor();
-
-        if (successor.accepts(message.get_message_id()))
+        if (get_successor().accepts(message.get_message_id()))
         {
-          successor.receive(destination_router_id, message);
+          get_successor().receive(destination_router_id, message);
         }
       }
     }
@@ -306,11 +304,9 @@ namespace etl
 
       if (has_successor())
       {
-        etl::imessage_router& successor = get_successor();
-
-        if (successor.accepts(shared_msg.get_message().get_message_id()))
+        if (get_successor().accepts(shared_msg.get_message().get_message_id()))
         {
-          successor.receive(destination_router_id, shared_msg);
+          get_successor().receive(destination_router_id, shared_msg);
         }
       }
     }
@@ -319,11 +315,35 @@ namespace etl
 
     //*******************************************
     /// Does this message bus accept the message id?
-    /// Yes!, it accepts everything!
+    /// Returns <b>true</b> on the first router that does.
     //*******************************************
-    bool accepts(etl::message_id_t) const ETL_OVERRIDE
+    bool accepts(etl::message_id_t id) const ETL_OVERRIDE
     {
-      return true;
+      // Check the list of subscribed routers.
+      router_list_t::iterator irouter = router_list.begin();
+
+      while (irouter != router_list.end())
+      {
+        etl::imessage_router& router = **irouter;
+
+        if (router.accepts(id))
+        {
+          return true;
+        }
+
+        ++irouter;
+      }
+
+      // Check any successor.
+      if (has_successor())
+      {
+        if (get_successor().accepts(id))
+        {
+          return true;
+        }
+      }
+
+      return false;
     }
 
     //*******************************************
@@ -370,9 +390,9 @@ namespace etl
     //*******************************************
     /// Constructor.
     //*******************************************
-    imessage_bus(router_list_t& list, etl::imessage_router& successor)
-      : imessage_router(etl::imessage_router::MESSAGE_BUS, successor),
-      router_list(list)
+    imessage_bus(router_list_t& router_list_, etl::imessage_router& successor_)
+      : imessage_router(etl::imessage_router::MESSAGE_BUS, successor_),
+      router_list(router_list_)
     {
     }
 
@@ -416,8 +436,8 @@ namespace etl
     //*******************************************
     /// Constructor.
     //*******************************************
-    message_bus(etl::imessage_router& successor)
-      : imessage_bus(router_list, successor)
+    message_bus(etl::imessage_router& successor_)
+      : imessage_bus(router_list, successor_)
     {
     }
 
diff --git a/include/etl/message_packet.h b/include/etl/message_packet.h
index df4d6d29..35650a6b 100644
--- a/include/etl/message_packet.h
+++ b/include/etl/message_packet.h
@@ -99,7 +99,7 @@ namespace etl
     ///
     //********************************************
 #include "private/diagnostic_uninitialized_push.h"
-    template <typename T>
+    template <typename T, typename = typename etl::enable_if<IsIMessage<T> || IsInMessageList<T>, int>::type>
     explicit message_packet(T&& msg)
       : valid(true)
     {
@@ -121,10 +121,6 @@ namespace etl
       {
         add_new_message_type<T>(etl::forward<T>(msg));
       }
-      else if constexpr (IsMessagePacket<T>)
-      {
-        copy(etl::forward<T>(msg));
-      }
       else
       {
         ETL_STATIC_ASSERT(IsInMessageList<T>, "Message not in packet type list");
@@ -132,6 +128,30 @@ namespace etl
     }
 #include "private/diagnostic_pop.h"
 
+    //**********************************************
+    message_packet(const message_packet& other)
+    {
+      valid = other.is_valid();
+
+      if (valid)
+      {
+        add_new_message(other.get());
+      }
+    }
+
+#if ETL_USING_CPP11
+    //**********************************************
+    message_packet(message_packet&& other)
+    {
+      valid = other.is_valid();
+
+      if (valid)
+      {
+        add_new_message(etl::move(other.get()));
+      }
+    }
+#endif
+
     //**********************************************
     void copy(const message_packet& other)
     {
diff --git a/include/etl/message_router.h b/include/etl/message_router.h
index b7807a77..3f846ef9 100644
--- a/include/etl/message_router.h
+++ b/include/etl/message_router.h
@@ -39,7 +39,7 @@ SOFTWARE.
 // Note: You will need Python and COG installed.
 //
 // python -m cogapp -d -e -omessage_router.h -DHandlers=<n> message_router_generator.h
-// Where <n> is the number of messages to support.
+// Where <n> is the maximum number of messages to support.
 //
 // e.g.
 // To generate handlers for up to 16 messages...
@@ -200,8 +200,8 @@ namespace etl
     }
 
     //********************************************
-    null_message_router(etl::imessage_router& successor)
-      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor)
+    null_message_router(etl::imessage_router& successor_)
+      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
     {
     }
     
@@ -278,8 +278,8 @@ namespace etl
     }
 
     //********************************************
-    message_producer(etl::imessage_router& successor)
-      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor)
+    message_producer(etl::imessage_router& successor_)
+      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
     {
     }
 
@@ -291,8 +291,8 @@ namespace etl
     }
 
     //********************************************
-    message_producer(etl::message_router_id_t id_, etl::imessage_router& successor)
-      : imessage_router(id_, successor)
+    message_producer(etl::message_router_id_t id_, etl::imessage_router& successor_)
+      : imessage_router(id_, successor_)
     {
       ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
     }
@@ -342,11 +342,22 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Is T ultimately derived from etl::imessage_router?
+  //***************************************************************************
+  template <typename T>
+  struct is_message_router : public etl::bool_constant<etl::is_base_of<etl::imessage_router, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
   //***************************************************************************
   /// Send a message to a router.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  const etl::imessage&  message)
+  template <typename TRouter, typename TMessage>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    send_message(TRouter&        destination,
+                 const TMessage& message)
   {
     destination.receive(message);
   }
@@ -354,8 +365,11 @@ namespace etl
   //***************************************************************************
   /// Send a shared message to a router.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::shared_message message)
+  template <typename TRouter>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    send_message(TRouter&            destination,
+                 etl::shared_message message)
   {
     destination.receive(message);
   }
@@ -363,9 +377,12 @@ namespace etl
   //***************************************************************************
   /// Send a message to a router with a particular id.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::message_router_id_t id,
-                                  const etl::imessage& message)
+  template <typename TRouter, typename TMessage>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    send_message(TRouter&                 destination,
+                 etl::message_router_id_t id,
+                 const TMessage&          message)
   {
     destination.receive(id, message);
   }
@@ -373,9 +390,12 @@ namespace etl
   //***************************************************************************
   /// Send a shared message to a router with a particular id.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::message_router_id_t id,
-                                  etl::shared_message message)
+  template <typename TRouter>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    send_message(TRouter&                 destination,
+                 etl::message_router_id_t id,
+                 etl::shared_message      message)
   {
     destination.receive(id, message);
   }
diff --git a/include/etl/message_timer.h b/include/etl/message_timer.h
index 075b03ad..f272877b 100644
--- a/include/etl/message_timer.h
+++ b/include/etl/message_timer.h
@@ -589,13 +589,31 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      ETL_DISABLE_TIMER_UPDATES;
+      bool result = !active_list.empty();
+      ETL_ENABLE_TIMER_UPDATES;
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       ETL_DISABLE_TIMER_UPDATES;
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {        
+        delta = active_list.front().delta;
+      }
       ETL_ENABLE_TIMER_UPDATES;
 
       return delta;
diff --git a/include/etl/message_timer_atomic.h b/include/etl/message_timer_atomic.h
index 97fb3183..2710ea29 100644
--- a/include/etl/message_timer_atomic.h
+++ b/include/etl/message_timer_atomic.h
@@ -302,13 +302,31 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      ++process_semaphore;
+      bool result = !active_list.empty();
+      --process_semaphore;
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       ++process_semaphore;
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
       --process_semaphore;
 
       return delta;
diff --git a/include/etl/message_timer_interrupt.h b/include/etl/message_timer_interrupt.h
index c906d8ef..6f26789a 100644
--- a/include/etl/message_timer_interrupt.h
+++ b/include/etl/message_timer_interrupt.h
@@ -312,14 +312,30 @@ namespace etl
     }
 
     //*******************************************
-    /// Get the time to the next timer event.
+    /// Check if there is an active timer.
     //*******************************************
-    uint32_t time_to_next() const
+    bool has_active_timer() const
     {
       TInterruptGuard guard;
       (void)guard; // Silence 'unused variable warnings.
+      return !active_list.empty();
+    }
 
-      uint32_t delta = active_list.front().delta;
+    //*******************************************
+    /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
+    //*******************************************
+    uint32_t time_to_next() const
+    {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
+      TInterruptGuard guard;
+      (void)guard; // Silence 'unused variable warnings.
+
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
 
       return delta;
     }
diff --git a/include/etl/message_timer_locked.h b/include/etl/message_timer_locked.h
index cd44702e..5639dc2f 100644
--- a/include/etl/message_timer_locked.h
+++ b/include/etl/message_timer_locked.h
@@ -318,14 +318,32 @@ namespace etl
       unlock   = unlock_;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      lock();
+      bool result = !active_list.empty();
+      unlock();
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
-      lock();
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
 
-      uint32_t delta = active_list.front().delta;
+      lock();
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
+      unlock();
 
       return delta;
     }
diff --git a/include/etl/multi_range.h b/include/etl/multi_range.h
index 44c02110..e8297ca8 100644
--- a/include/etl/multi_range.h
+++ b/include/etl/multi_range.h
@@ -324,7 +324,7 @@ namespace etl
     {
       typedef T value_type;
 
-      virtual bool operator()(const value_type& current, const value_type& last) const = 0;
+      virtual bool operator()(const value_type& lhs, const value_type& rhs) const = 0;
     };
 
     //***************************************************************************
@@ -334,9 +334,9 @@ namespace etl
     {
       typedef T value_type;
 
-      virtual bool operator()(const value_type& current, const value_type& last) const ETL_OVERRIDE
+      virtual bool operator()(const value_type& lhs, const value_type& rhs) const ETL_OVERRIDE
       {
-        return etl::not_equal_to<value_type>()(current, last);
+        return etl::not_equal_to<value_type>()(lhs, rhs);
       }
     };
 
@@ -347,9 +347,9 @@ namespace etl
     {
       typedef T value_type;
 
-      virtual bool operator()(const value_type& current, const value_type& last) const ETL_OVERRIDE
+      virtual bool operator()(const value_type& lhs, const value_type& rhs) const ETL_OVERRIDE
       {
-        return etl::less<value_type>()(current, last);
+        return etl::less<value_type>()(lhs, rhs);
       }
     };
 
@@ -360,9 +360,9 @@ namespace etl
     {
       typedef T value_type;
 
-      virtual bool operator()(const value_type& current, const value_type& last) const ETL_OVERRIDE
+      virtual bool operator()(const value_type& lhs, const value_type& rhs) const ETL_OVERRIDE
       {
-        return etl::greater<value_type>()(current, last);
+        return etl::greater<value_type>()(lhs, rhs);
       }
     };
 
diff --git a/include/etl/multimap.h b/include/etl/multimap.h
index a6411cc3..6d9dfa6f 100644
--- a/include/etl/multimap.h
+++ b/include/etl/multimap.h
@@ -1542,10 +1542,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(const_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new (&node.value) const value_type(value);
+      Data_Node* node = allocate_data_node();
+      ::new (&node->value) const value_type(value);
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #if ETL_USING_CPP11
@@ -1554,20 +1554,20 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(rvalue_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new (&node.value) const value_type(etl::move(value));
+      Data_Node* node = allocate_data_node();
+      ::new (&node->value) const value_type(etl::move(value));
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 #endif
 
     //*************************************************************************
     /// Create a Data_Node.
     //*************************************************************************
-    Data_Node& allocate_data_node()
+    Data_Node* allocate_data_node()
     {
       Data_Node* (etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
-      return *(p_node_pool->*func)();
+      return (p_node_pool->*func)();
     }
 
     //*************************************************************************
diff --git a/include/etl/multiset.h b/include/etl/multiset.h
index d2c35f68..596c31d6 100644
--- a/include/etl/multiset.h
+++ b/include/etl/multiset.h
@@ -1530,10 +1530,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(const_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new ((void*)&node.value) value_type(value);
+      Data_Node* node = allocate_data_node();
+      ::new ((void*)&node->value) value_type(value);
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #if ETL_USING_CPP11
@@ -1542,20 +1542,20 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(rvalue_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new ((void*)&node.value) value_type(etl::move(value));
+      Data_Node* node = allocate_data_node();
+      ::new ((void*)&node->value) value_type(etl::move(value));
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 #endif
 
     //*************************************************************************
     /// Create a Data_Node.
     //*************************************************************************
-    Data_Node& allocate_data_node()
+    Data_Node* allocate_data_node()
     {
       Data_Node* (etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
-      return *(p_node_pool->*func)();
+      return (p_node_pool->*func)();
     }
 
     //*************************************************************************
diff --git a/include/etl/optional.h b/include/etl/optional.h
index 6431efb5..002d010a 100644
--- a/include/etl/optional.h
+++ b/include/etl/optional.h
@@ -97,6 +97,1120 @@ namespace etl
     }
   };
 
+  //*****************************************************************************
+  // Implementations for fundamental and non fundamental types.
+  //*****************************************************************************
+  namespace private_optional
+  {
+    template <typename T, bool IsDefaultConstructible = etl::is_integral<T>::value>
+    class optional_impl;
+
+    //*****************************************************************************
+    // Implementation for non fundamental types.
+    //*****************************************************************************
+    template <typename T>
+    class optional_impl<T, false>
+    {
+    protected:
+
+      typedef T value_type;
+
+      //***************************************************************************
+      /// Constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl()
+        : storage()
+      {
+      }
+
+      //***************************************************************************
+      /// Constructor with nullopt.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(etl::nullopt_t)
+        : storage()
+      {
+      }
+
+#include "private/diagnostic_uninitialized_push.h"
+      //***************************************************************************
+      /// Copy constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(const optional_impl<T>& other)
+      {
+        if (other.has_value())
+        {
+          storage.construct(other.value());
+        }
+      }
+#include "private/diagnostic_pop.h"
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Move constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(optional_impl<T>&& other)
+      {
+        if (other.has_value())
+        {
+          storage.construct(etl::move(other.value()));
+        }
+      }
+#endif
+
+      //***************************************************************************
+      /// Constructor from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(const T& value_)
+      {
+        storage.construct(value_);
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Constructor from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(T&& value_)
+      {
+        storage.construct(etl::move(value_));
+      }
+#endif
+
+      //***************************************************************************
+      /// Destructor.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      ~optional_impl()
+      {
+        storage.destroy();
+      }
+
+      //***************************************************************************
+      /// Assignment operator from nullopt.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(etl::nullopt_t)
+      {
+        if (has_value())
+        {
+          storage.destroy();
+        }
+
+        return *this;
+      }
+
+      //***************************************************************************
+      /// Assignment operator from optional_impl.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(const optional_impl<T>& other)
+      {
+        if (this != &other)
+        {
+          if (other.has_value())
+          {
+            storage.construct(other.value());
+          }
+          else
+          {
+            storage.destroy();
+          }
+        }
+
+        return *this;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Assignment operator from optional_impl.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(optional_impl&& other)
+      {
+        if (this != &other)
+        {
+          if (other.has_value())
+          {
+            storage.construct(etl::move(other.value()));
+          }
+          else
+          {
+            storage.destroy();
+          }
+        }
+
+        return *this;
+      }
+#endif
+
+      //***************************************************************************
+      /// Assignment operator from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(const T& value_)
+      {
+        storage.construct(value_);
+
+        return *this;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Assignment operator from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(T&& value_)
+      {
+        storage.construct(etl::move(value_));
+
+        return *this;
+      }
+#endif
+
+  public:
+
+      //***************************************************************************
+      /// Pointer operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T* operator ->()
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return &storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Pointer operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T* operator ->() const
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return &storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T& operator *() ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T& operator *() const ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.u.value;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T&& operator *()&&
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.u.value);
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T&& operator *() const&&
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.u.value);
+      }
+#endif
+
+      //***************************************************************************
+      // Check whether optional contains value
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      bool has_value() const ETL_NOEXCEPT
+      {
+        return storage.valid;
+      }
+
+      //***************************************************************************
+      /// Bool conversion operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      ETL_EXPLICIT operator bool() const
+      {
+        return has_value();
+      }
+
+      //***************************************************************************
+      /// Get a reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T& value() ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Get a const reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T& value() const ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
+      {
+        return has_value() ? value() : default_value;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Get an rvalue reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T&& value()&&
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.u.value);
+      }
+
+      //***************************************************************************
+      /// Get a const rvalue reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T&& value() const&&
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.u.value);
+      }
+
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      template <typename U>
+      ETL_CONSTEXPR20_STL
+      etl::enable_if_t<etl::is_convertible<U, T>::value, T>
+        value_or(U&& default_value) const&
+      {
+        return has_value() ? value() : etl::forward<T>(default_value);
+      }
+
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      template <typename U>
+      ETL_CONSTEXPR20_STL
+      etl::enable_if_t<etl::is_convertible<U, T>::value, T>
+        value_or(U&& default_value)&&
+      {
+        return has_value() ? etl::move(value()) : etl::forward<T>(default_value);
+      }
+#endif
+
+      //***************************************************************************
+      /// Swaps this value with another.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      void swap(optional_impl& other)
+      {
+        optional_impl temp(*this);
+        *this = other;
+        other = temp;
+      }
+
+      //***************************************************************************
+      /// Reset back to invalid.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      void reset()
+      {
+        storage.destroy();
+      }
+
+#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
+      //*************************************************************************
+      /// Emplaces a value.
+      ///\param args The arguments to construct with.
+      //*************************************************************************
+      template <typename... TArgs>
+      ETL_CONSTEXPR20_STL
+      void emplace(TArgs&& ... args)
+      {
+        storage.construct(etl::forward<TArgs>(args)...);
+      }
+#else
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 1 parameter.
+      //*************************************************************************
+      T& emplace()
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T();
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 1 parameter.
+      //*************************************************************************
+      template <typename T1>
+      T& emplace(const T1& value1)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T(value1);
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 2 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2>
+      T& emplace(const T1& value1, const T2& value2)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T(value1, value2);
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 3 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2, typename T3>
+      T& emplace(const T1& value1, const T2& value2, const T3& value3)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T(value1, value2, value3);
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 4 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2, typename T3, typename T4>
+      T& emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T(value1, value2, value3, value4);
+        storage.valid = true;
+
+        return *p;
+      }
+#endif
+
+    private:
+
+      struct dummy_t {};
+
+      //*************************************
+      // The storage for the optional value.
+      //*************************************
+      struct storage_type
+      {
+        //*******************************
+        ETL_CONSTEXPR20_STL
+        storage_type()
+          : u()
+          , valid(false)
+        {
+        }
+
+        //*******************************
+        ETL_CONSTEXPR20_STL
+        void construct(const T& value_)
+        {
+          if (valid)
+          {
+            etl::destroy_at(&u.value);
+          }
+
+          etl::construct_at(&u.value, value_);
+          valid = true;
+        }
+
+#if ETL_USING_CPP11
+        //*******************************
+        ETL_CONSTEXPR20_STL
+        void construct(T&& value_)
+        {
+          if (valid)
+          {
+            etl::destroy_at(&u.value);
+          }
+
+          etl::construct_at(&u.value, etl::move(value_));
+          valid = true;
+        }
+
+        //*******************************
+        template <typename... TArgs>
+        ETL_CONSTEXPR20_STL
+        void construct(TArgs&&... args)
+        {
+          if (valid)
+          {
+            etl::destroy_at(&u.value);
+          }
+
+          etl::construct_at(&u.value, etl::forward<TArgs>(args)...);
+          valid = true;
+        }
+#endif
+
+        //*******************************
+        ETL_CONSTEXPR20_STL
+        void destroy()
+        {
+          if (valid)
+          {
+            etl::destroy_at(&u.value);
+            valid = false;
+          }
+        }
+
+        //*******************************
+        union union_type
+        {
+          ETL_CONSTEXPR20_STL
+          union_type()
+            : dummy()
+          {
+          }
+
+          ETL_CONSTEXPR20_STL
+          ~union_type()
+          {
+          }
+
+          dummy_t dummy;
+          T       value;
+        } u;
+
+        bool valid;
+      };
+
+      storage_type storage;
+    };
+
+    //*****************************************************************************
+    // Implementation for fundamental types.
+    //*****************************************************************************
+    template <typename T>
+    class optional_impl<T, true>
+    {
+    protected:
+
+      typedef T value_type;
+
+      //***************************************************************************
+      /// Constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl()
+        : storage()
+      {
+      }
+
+      //***************************************************************************
+      /// Constructor with nullopt.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(etl::nullopt_t)
+        : storage()
+      {
+      }
+
+#include "private/diagnostic_uninitialized_push.h"
+      //***************************************************************************
+      /// Copy constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(const optional_impl<T>& other)
+      {
+        if (other.has_value())
+        {
+          storage.construct(other.value());
+        }
+      }
+#include "private/diagnostic_pop.h"
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Move constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(optional_impl&& other)
+      {
+        if (other.has_value())
+        {
+          storage.construct(etl::move(other.value()));
+        }
+      }
+#endif
+
+      //***************************************************************************
+      /// Constructor from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(const T& value_)
+      {
+        storage.construct(value_);
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Constructor from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(T&& value_)
+      {
+        storage.construct(etl::move(value_));
+      }
+#endif
+
+      //***************************************************************************
+      /// Assignment operator from nullopt.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(etl::nullopt_t)
+      {
+        if (has_value())
+        {
+          storage.destroy();
+        }
+
+        return *this;
+      }
+
+      //***************************************************************************
+      /// Assignment operator from optional_impl.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(const optional_impl<T>& other)
+      {
+        if (this != &other)
+        {
+          if (other.has_value())
+          {
+            storage.construct(other.value());
+          }
+          else
+          {
+            storage.destroy();
+          }
+        }
+
+        return *this;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Assignment operator from optional_impl.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(optional_impl&& other)
+      {
+        if (this != &other)
+        {
+          if (other.has_value())
+          {
+            storage.construct(etl::move(other.value()));
+          }
+          else
+          {
+            storage.destroy();
+          }
+        }
+
+        return *this;
+      }
+#endif
+
+      //***************************************************************************
+      /// Assignment operator from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(const T& value_)
+      {
+        storage.construct(value_);
+
+        return *this;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Assignment operator from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(T&& value_)
+      {
+        storage.construct(etl::move(value_));
+
+        return *this;
+      }
+#endif
+
+  public:
+
+      //***************************************************************************
+      /// Pointer operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T* operator ->()
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return &storage.value;
+      }
+
+      //***************************************************************************
+      /// Pointer operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T* operator ->() const
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return &storage.value;
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T& operator *() ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.value;
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T& operator *() const ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.value;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T&& operator *()&&
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.value);
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T&& operator *() const&&
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.value);
+      }
+#endif
+
+      //***************************************************************************
+      // Check whether optional contains value
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      bool has_value() const ETL_NOEXCEPT
+      {
+        return storage.valid;
+      }
+
+      //***************************************************************************
+      /// Bool conversion operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      ETL_EXPLICIT operator bool() const
+      {
+        return has_value();
+      }
+
+      //***************************************************************************
+      /// Get a reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T& value() ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.value;
+      }
+
+      //***************************************************************************
+      /// Get a const reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T& value() const ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.value;
+      }
+
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
+      {
+        return has_value() ? value() : default_value;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Get an rvalue reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T&& value()&&
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.value);
+      }
+
+      //***************************************************************************
+      /// Get a const rvalue reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T&& value() const&&
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.value);
+      }
+
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      template <typename U>
+      ETL_CONSTEXPR14
+      etl::enable_if_t<etl::is_convertible<U, T>::value, T>
+        value_or(U&& default_value) const&
+      {
+        return has_value() ? value() : etl::forward<T>(default_value);
+      }
+
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      template <typename U>
+      ETL_CONSTEXPR14
+      etl::enable_if_t<etl::is_convertible<U, T>::value, T>
+        value_or(U&& default_value)&&
+      {
+        return has_value() ? etl::move(value()) : etl::forward<T>(default_value);
+      }
+#endif
+
+      //***************************************************************************
+      /// Swaps this value with another.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      void swap(optional_impl& other)
+      {
+        optional_impl temp(*this);
+        *this = other;
+        other = temp;
+      }
+
+      //***************************************************************************
+      /// Reset back to invalid.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      void reset()
+      {
+        storage.destroy();
+      }
+
+#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
+      //*************************************************************************
+      /// Emplaces a value.
+      ///\param args The arguments to construct with.
+      //*************************************************************************
+      template <typename... TArgs>
+      ETL_CONSTEXPR14
+      void emplace(TArgs&& ... args)
+      {
+        storage.construct(etl::forward<TArgs>(args)...);
+      }
+#else
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 1 parameter.
+      //*************************************************************************
+      T& emplace()
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.value) T();
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 1 parameter.
+      //*************************************************************************
+      template <typename T1>
+      T& emplace(const T1& value1)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.value) T(value1);
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 2 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2>
+      T& emplace(const T1& value1, const T2& value2)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.value) T(value1, value2);
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 3 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2, typename T3>
+      T& emplace(const T1& value1, const T2& value2, const T3& value3)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.value) T(value1, value2, value3);
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 4 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2, typename T3, typename T4>
+      T& emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.value) T(value1, value2, value3, value4);
+        storage.valid = true;
+
+        return *p;
+      }
+#endif
+
+    private:
+
+      //*************************************
+      // The storage for the optional value.
+      //*************************************
+      struct storage_type
+      {
+        //*******************************
+        ETL_CONSTEXPR14
+        storage_type()
+          : value()
+          , valid(false)
+        {
+        }
+
+        //*******************************
+        ETL_CONSTEXPR14
+        void construct(const T& value_)
+        {
+          value = value_;
+          valid   = true;
+        }
+
+#if ETL_USING_CPP11
+        //*******************************
+        ETL_CONSTEXPR14
+        void construct(T&& value_)
+        {
+          value = value_;
+          valid = true;
+        }
+
+        //*******************************
+        template <typename... TArgs>
+        ETL_CONSTEXPR14
+        void construct(TArgs&&... args)
+        {
+          value = T(etl::forward<TArgs>(args)...);
+          valid = true;
+        }
+#endif
+
+        //*******************************
+        ETL_CONSTEXPR14
+        void destroy()
+        {
+          valid = false;
+        }
+
+        T    value;
+        bool valid;
+      };
+
+      storage_type storage;
+    };
+  }
+
+#define ETL_OPTIONAL_ENABLE_CPP14     typename etl::enable_if< etl::is_pod<U>::value, int>::type = 0
+#define ETL_OPTIONAL_ENABLE_CPP20_STL typename etl::enable_if<!etl::is_pod<U>::value, int>::type = 0
+
+#define ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14     ETL_CONSTEXPR14     typename etl::enable_if< etl::is_pod<T>::value, bool>::type
+#define ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL ETL_CONSTEXPR20_STL typename etl::enable_if<!etl::is_pod<T>::value, bool>::type
+
   //*****************************************************************************
   /// An optional type.
   /// If the optional type is not initialised then a type is not constructed.
@@ -104,1016 +1218,340 @@ namespace etl
   ///\tparam T The type to store.
   ///\ingroup utilities
   //*****************************************************************************
-  template <typename T, bool is_pod = etl::is_pod<T>::value>
-  class optional;
-
-  //*****************************************************************************
-  /// For non POD types.
-  //*****************************************************************************
   template <typename T>
-  class optional<T, false>
+  class optional : public private_optional::optional_impl<T>
   {
+  private:
+
+    typedef private_optional::optional_impl<T> impl_t;
+    
   public:
 
     typedef T value_type;
 
+#if ETL_USING_CPP11
     //***************************************************************************
     /// Constructor.
     //***************************************************************************
-    ETL_CONSTEXPR
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
     optional()
-      : storage()
+      : impl_t()
+    {
+    }
+
+    //***************************************************************************
+    /// Constructor.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional()
+      : impl_t()
+    {
+    }
+#else
+    optional()
+      : impl_t()
+    {
+    }
+#endif
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Constructor with nullopt.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional(etl::nullopt_t)
+      : impl_t(etl::nullopt)
     {
     }
 
     //***************************************************************************
     /// Constructor with nullopt.
     //***************************************************************************
-    ETL_CONSTEXPR
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
     optional(etl::nullopt_t)
-      : storage()
+      : impl_t(etl::nullopt)
     {
     }
+#else
+    //***************************************************************************
+    /// Constructor with nullopt.
+    //***************************************************************************
+    optional(etl::nullopt_t)
+      : impl_t(etl::nullopt)
+    {
+    }
+#endif
 
 #include "private/diagnostic_uninitialized_push.h"
+#if ETL_USING_CPP11
     //***************************************************************************
     /// Copy constructor.
     //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional(const optional& other)
+      : impl_t(other)
+    {
+    }
+
+    //***************************************************************************
+    /// Copy constructor.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
     ETL_CONSTEXPR20_STL
     optional(const optional& other)
+      : impl_t(other)
     {
-      if (other.has_value())
-      {
-        storage.construct(other.value());
-      }
     }
+#else
+    //***************************************************************************
+    /// Copy constructor.
+    //***************************************************************************
+    optional(const optional& other)
+      : impl_t(other)
+    {
+    }
+#endif
 #include "private/diagnostic_pop.h"
 
 #if ETL_USING_CPP11
     //***************************************************************************
     /// Move constructor.
     //***************************************************************************
-    ETL_CONSTEXPR20_STL
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
     optional(optional&& other)
-    {
-      if (other.has_value())
-      {
-        storage.construct(etl::move(other.value()));
-      }
-    }
-#endif
-
-    //***************************************************************************
-    /// Constructor from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional(const T& value_)
-    {
-      storage.construct(value_);
-    }
-
-#if ETL_USING_CPP11
-    //***************************************************************************
-    /// Constructor from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional(T&& value_)
-    {
-      storage.construct(etl::move(value_));
-    }
-#endif
-
-    //***************************************************************************
-    /// Destructor.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    ~optional()
-    {
-      storage.destroy();
-    }
-
-    //***************************************************************************
-    /// Assignment operator from nullopt.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(etl::nullopt_t)
-    {
-      if (has_value())
-      {
-        storage.destroy();
-      }
-
-      return *this;
-    }
-
-    //***************************************************************************
-    /// Assignment operator from optional.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(const optional& other)
-    {
-      if (this != &other)
-      {
-        if (other.has_value())
-        {
-          storage.construct(other.value());
-        }
-        else
-        {
-          storage.destroy();
-        }
-      }
-
-      return *this;
-    }
-
-#if ETL_USING_CPP11
-    //***************************************************************************
-    /// Assignment operator from optional.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(optional&& other)
-    {
-      if (this != &other)
-      {
-        if (other.has_value())
-        {
-          storage.construct(etl::move(other.value()));
-        }
-        else
-        {
-          storage.destroy();
-        }
-      }
-
-      return *this;
-    }
-#endif
-
-    //***************************************************************************
-    /// Assignment operator from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(const T& value_)
-    {
-      storage.construct(value_);
-
-      return *this;
-    }
-
-#if ETL_USING_CPP11
-    //***************************************************************************
-    /// Assignment operator from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(T&& value_)
-    {
-      storage.construct(etl::move(value_));
-
-      return *this;
-    }
-#endif
-
-    //***************************************************************************
-    /// Pointer operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T* operator ->()
-    {
-#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return &storage.u.value;
-    }
-
-    //***************************************************************************
-    /// Pointer operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T* operator ->() const
-    {
-#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return &storage.u.value;
-    }
-
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T& operator *() ETL_LVALUE_REF_QUALIFIER
-    {
-#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return storage.u.value;
-    }
-
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T& operator *() const ETL_LVALUE_REF_QUALIFIER
-    {
-#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return storage.u.value;
-    }
-
-#if ETL_USING_CPP11
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T&& operator *()&&
-    {
-#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.u.value);
-    }
-
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T&& operator *() const&&
-    {
-#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.u.value);
-    }
-#endif
-
-    //***************************************************************************
-    // Check whether optional contains value
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    bool has_value() const ETL_NOEXCEPT
-    {
-      return storage.valid;
-    }
-
-    //***************************************************************************
-    /// Bool conversion operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    ETL_EXPLICIT operator bool() const
-    {
-      return has_value();
-    }
-
-    //***************************************************************************
-    /// Get a reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T& value() ETL_LVALUE_REF_QUALIFIER
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return storage.u.value;
-    }
-
-    //***************************************************************************
-    /// Get a const reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T& value() const ETL_LVALUE_REF_QUALIFIER
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return storage.u.value;
-    }
-
-    //***************************************************************************
-    /// Gets the value or a default if not valid.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
-    {
-      return has_value() ? value() : default_value;
-    }
-
-#if ETL_USING_CPP11
-    //***************************************************************************
-    /// Get an rvalue reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T&& value()&&
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.u.value);
-    }
-
-    //***************************************************************************
-    /// Get a const rvalue reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T&& value() const&&
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.u.value);
-    }
-
-    //***************************************************************************
-    /// Gets the value or a default if not valid.
-    //***************************************************************************
-    template <typename U>
-    ETL_CONSTEXPR20_STL
-    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
-      value_or(U&& default_value) const&
-    {
-      return has_value() ? value() : etl::forward<T>(default_value);
-    }
-
-    //***************************************************************************
-    /// Gets the value or a default if not valid.
-    //***************************************************************************
-    template <typename U>
-    ETL_CONSTEXPR20_STL
-    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
-      value_or(U&& default_value) &&
-    {
-      return has_value() ? etl::move(value()) : etl::forward<T>(default_value);
-    }
-#endif
-
-    //***************************************************************************
-    /// Swaps this value with another.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    void swap(optional& other)
-    {
-      optional temp(*this);
-      *this = other;
-      other = temp;
-    }
-
-    //***************************************************************************
-    /// Reset back to invalid.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    void reset()
-    {
-      storage.destroy();
-    }
-
-#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
-    //*************************************************************************
-    /// Emplaces a value.
-    ///\param args The arguments to construct with.
-    //*************************************************************************
-    template <typename ... TArgs>
-    ETL_CONSTEXPR20_STL
-    void emplace(TArgs&& ... args)
-    {
-      storage.construct(etl::forward<TArgs>(args)...);
-    }
-#else
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 1 parameter.
-    //*************************************************************************
-    T& emplace()
-    {
-      if (has_value())
-      {
-        // Destroy the old one.
-        storage.destroy();
-      }
-
-      T* p = ::new (&storage.u.value) T();
-      storage.valid = true;
-
-      return *p;
-    }
-
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 1 parameter.
-    //*************************************************************************
-    template <typename T1>
-    T& emplace(const T1& value1)
-    {
-      if (has_value())
-      {
-        // Destroy the old one.
-        storage.destroy();
-      }
-
-      T* p = ::new (&storage.u.value) T(value1);
-      storage.valid = true;
-
-      return *p;
-    }
-
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 2 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2>
-    T& emplace(const T1& value1, const T2& value2)
-    {
-      if (has_value())
-      {
-        // Destroy the old one.
-        storage.destroy();
-      }
-
-      T* p = ::new (&storage.u.value) T(value1, value2);
-      storage.valid = true;
-
-      return *p;
-    }
-
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 3 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2, typename T3>
-    T& emplace(const T1& value1, const T2& value2, const T3& value3)
-    {
-      if (has_value())
-      {
-        // Destroy the old one.
-        storage.destroy();
-      }
-
-      T* p = ::new (&storage.u.value) T(value1, value2, value3);
-      storage.valid = true;
-
-      return *p;
-    }
-
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 4 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2, typename T3, typename T4>
-    T& emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
-    {
-      if (has_value())
-      {
-        // Destroy the old one.
-        storage.destroy();
-      }
-
-      T* p = ::new (&storage.u.value) T(value1, value2, value3, value4);
-      storage.valid = true;
-
-      return *p;
-    }
-#endif
-
-  private:
-
-    struct dummy_t {};
-
-    struct storage_type
-    {
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      storage_type()
-        : u()
-        , valid(false)
-      {
-      }
-
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      ~storage_type()
-      {
-        destroy();
-      }
-
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      void construct(const T& value_)
-      {
-        if (valid)
-        {
-          u.value = value_;
-        }
-        else
-        {
-          etl::construct_at(&u.value, value_);
-          valid = true;
-        }
-      }
-
-#if ETL_USING_CPP11
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      void construct(T&& value_)
-      {
-        if (valid)
-        {
-          u.value = etl::move(value_);
-        }
-        else
-        {
-          etl::construct_at(&u.value, etl::move(value_));
-          valid = true;
-        }
-      }
-
-      //*******************************
-      template <typename... TArgs>
-      ETL_CONSTEXPR20_STL
-      void construct(TArgs&&... args)
-      {
-        destroy();
-        etl::construct_at(&u.value, etl::forward<TArgs>(args)...);
-        valid = true;
-      }
-#endif
-
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      void destroy()
-      {
-        if (valid)
-        {
-          etl::destroy_at(&u.value);
-          valid = false;
-        }
-      }
-
-      //*******************************
-      union union_type
-      {
-        ETL_CONSTEXPR20_STL
-        union_type()
-          : dummy()
-        {
-        }
-
-        ETL_CONSTEXPR20_STL
-        ~union_type()
-        {
-        }
-
-        dummy_t dummy;
-        T       value;
-      } u;
-
-      bool valid;
-    };
-
-    storage_type storage;
-  };
-
-  //*****************************************************************************
-  /// For arithmetic or pointer types.
-  ///\tparam T The type to store.
-  ///\ingroup utilities
-  //*****************************************************************************
-  template <typename T>
-  class optional<T, true>
-  {
-  public:
-
-    typedef T value_type;
-
-    //***************************************************************************
-    /// Constructor.
-    //***************************************************************************
-    ETL_CONSTEXPR14 optional()
-      : valid(false)
-      , storage()
+      : impl_t(other)
     {
     }
 
-    //***************************************************************************
-    /// Constructor with nullopt.
-    //***************************************************************************
-    ETL_CONSTEXPR14 optional(etl::nullopt_t)
-      : valid(false)
-      , storage()
-    {
-    }
-
-    //***************************************************************************
-    /// Copy constructor.
-    //***************************************************************************
-    ETL_CONSTEXPR14 optional(const optional& other)
-      : valid(bool(other))
-      , storage(other.storage)
-    {
-    }
-
-#if ETL_USING_CPP11
     //***************************************************************************
     /// Move constructor.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional(optional&& other)
-      : valid(bool(other))
-      , storage(etl::move(other.storage))
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional(optional&& other)
+      : impl_t(other)
     {
     }
 #endif
 
-    //***************************************************************************
-    /// Constructor from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR14 optional(const T& value_)
-      : valid(true)
-      , storage(value_)
-    {
-    }
-
 #if ETL_USING_CPP11
     //***************************************************************************
-    /// Constructor from value type.
+    /// Construct from value type.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional(T&& value_)
-      : valid(true)
-      , storage(etl::move(value_))
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional(const T& value_)
+      : impl_t(value_)
+    {
+    }
+
+    //***************************************************************************
+    /// Construct from value type.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional(const T& value_)
+      : impl_t(value_)
+    {
+    }
+#else
+    //***************************************************************************
+    /// Construct from value type.
+    //***************************************************************************
+    optional(const T& value_)
+      : impl_t(value_)
     {
     }
 #endif
 
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Move construct from value type.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional(T&& value_)
+      : impl_t(etl::move(value_))
+    {
+    }
+
+    //***************************************************************************
+    /// Move construct from value type.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional(T&& value_)
+      : impl_t(etl::move(value_))
+    {
+    }
+#endif
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Assignment operator from nullopt.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional& operator =(etl::nullopt_t)
+    {
+      impl_t::operator=(etl::nullopt);
+
+      return *this;
+    }
+
     //***************************************************************************
     /// Assignment operator from nullopt.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(etl::nullopt_t)
-    {
-      valid = false;
-      return *this;
-    }
-
-    //***************************************************************************
-    /// Assignment operator from optional.
-    //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(const optional& other)
-    {
-      if (this != &other)
-      {
-        if (other.valid)
-        {
-          storage.value = other.storage.value;
-        }
-        valid = other.valid;
-      }
-
-      return *this;
-    }
-
-#if ETL_USING_CPP11
-    //***************************************************************************
-    /// Assignment operator from optional.
-    //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(optional&& other)
-    {
-      if (this != &other)
-      {
-        if (other.valid)
-        {
-          storage.value = etl::move(other.storage.value);
-        }
-        valid = other.valid;
-      }
-
-      return *this;
-    }
-#endif
-
-    //***************************************************************************
-    /// Assignment operator from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(const T& value_)
-    {
-      storage.value = value_;
-      valid = true;
-
-      return *this;
-    }
-
-#if ETL_USING_CPP11
-    //***************************************************************************
-    /// Assignment operator from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(T&& value_)
-    {
-      storage.value = etl::move(value_);
-      valid = true;
-
-      return *this;
-    }
-#endif
-
-    //***************************************************************************
-    /// Pointer operator.
-    //***************************************************************************
-    ETL_CONSTEXPR14 T* operator ->()
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return &storage.value;
-    }
-
-    //***************************************************************************
-    /// Pointer operator.
-    //***************************************************************************
-    ETL_CONSTEXPR14 const T* operator ->() const
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return &storage.value;
-    }
-
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR14 T& operator *() ETL_LVALUE_REF_QUALIFIER
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return storage.value;
-    }
-
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR14 const T& operator *() const ETL_LVALUE_REF_QUALIFIER
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return storage.value;
-    }
-
-#if ETL_USING_CPP11
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR14 T&& operator *()&&
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.value);
-    }
-
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR14 const T&& operator *() const&&
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.value);
-    }
-#endif
-
-    //***************************************************************************
-    /// Bool conversion operator.
-    //***************************************************************************
-    ETL_CONSTEXPR14
-    ETL_EXPLICIT operator bool() const
-    {
-      return valid;
-    }
-
-    //***************************************************************************
-    // Check whether optional contains value
-    //***************************************************************************
-    ETL_CONSTEXPR14 bool has_value() const ETL_NOEXCEPT
-    {
-      return valid;
-    }
-
-    //***************************************************************************
-    /// Get a reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR14 T& value() ETL_LVALUE_REF_QUALIFIER
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return storage.value;
-    }
-
-    //***************************************************************************
-    /// Get a const reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR14 const T& value() const ETL_LVALUE_REF_QUALIFIER
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return storage.value;
-    }
-
-    //***************************************************************************
-    /// Gets the value or a default if no valid.
-    //***************************************************************************
-    ETL_CONSTEXPR14 T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
-    {
-      return valid ? value() : default_value;
-    }
-
-#if ETL_USING_CPP11
-    //***************************************************************************
-    /// Get an rvalue reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR14 T&& value()&&
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.value);
-    }
-
-    //***************************************************************************
-    /// Get a const rvalue reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR14 const T&& value() const&&
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.value);
-    }
-
-    //***************************************************************************
-    /// Gets the value or a default if not valid.
-    //***************************************************************************
-    template <typename U>
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
     ETL_CONSTEXPR20_STL
-    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
-      value_or(U&& default_value) const&
+    optional& operator =(etl::nullopt_t)
     {
-      if (has_value())
-      {
-        return value();
-      }
-      else
-      {
-        return static_cast<T>(etl::forward<U>(default_value));
-      }
-    }
+      impl_t::operator=(etl::nullopt);
 
-    //***************************************************************************
-    /// Gets the value or a default if not valid.
-    //***************************************************************************
-    template <typename U>
-    ETL_CONSTEXPR20_STL
-    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
-      value_or(U&& default_value) &&
-    {
-      if (has_value())
-      {
-        return etl::move(value());
-      }
-      else
-      {
-        return static_cast<T>(etl::forward<U>(default_value));
-      }
-    }
-#endif
-
-    //***************************************************************************
-    /// Swaps this value with another.
-    //***************************************************************************
-    ETL_CONSTEXPR14 void swap(optional& other)
-    {
-      optional temp(*this);
-      *this = other;
-      other = temp;
-    }
-
-    //***************************************************************************
-    /// Reset back to invalid.
-    //***************************************************************************
-    ETL_CONSTEXPR14 void reset()
-    {
-      valid = false;
-    }
-
-#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
-    //*************************************************************************
-    /// Emplaces a value.
-    ///\param args The arguments to construct with.
-    //*************************************************************************
-    template <typename ... Args>
-    ETL_CONSTEXPR14 void emplace(Args && ... args)
-    {
-      storage.value = T(ETL_OR_STD::forward<Args>(args)...);
-      valid = true;
+      return *this;
     }
 #else
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 0 parameters.
-    //*************************************************************************
-    void emplace()
+    //***************************************************************************
+    /// Assignment operator from nullopt.
+    //***************************************************************************
+    optional& operator =(etl::nullopt_t)
     {
-      storage.value = value_type();
-      valid = true;
-    }
+      impl_t::operator=(etl::nullopt);
 
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 1 parameter.
-    //*************************************************************************
-    template <typename T1>
-    void emplace(const T1& value1)
-    {
-      storage.value = value1;
-      valid = true;
-    }
-
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 2 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2>
-    void emplace(const T1& value1, const T2& value2)
-    {
-      storage.value = T(value1, value2);
-      valid = true;
-    }
-
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 3 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2, typename T3>
-    void emplace(const T1& value1, const T2& value2, const T3& value3)
-    {
-      storage.value = T(value1, value2, value3);
-      valid = true;
-    }
-
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 4 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2, typename T3, typename T4>
-    void emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
-    {
-      storage.value = T(value1, value2, value3, value4);
-      valid = true;
+      return *this;
     }
 #endif
 
-  private:
-
-    bool valid;
-
-    struct dummy_t {};
-
-    union storage_type
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Assignment operator from optional.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional& operator =(const optional& other)
     {
-      dummy_t dummy;
-      T       value;
+      impl_t::operator=(other);
 
-      ETL_CONSTEXPR storage_type()
-        : dummy()
-      {
-      }
+      return *this;
+    }
 
-      ETL_CONSTEXPR storage_type(const T& v)
-        : value(v) 
-      {
-      }
-    };
+    //***************************************************************************
+    /// Assignment operator from optional.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional& operator =(const optional& other)
+    {
+      impl_t::operator=(other);
 
-    storage_type storage;
+      return *this;
+    }
+#else
+    //***************************************************************************
+    /// Assignment operator from optional.
+    //***************************************************************************
+    optional& operator =(const optional& other)
+    {
+      impl_t::operator=(other);
+
+      return *this;
+    }
+#endif
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Move assignment operator from optional.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+      optional& operator =(optional&& other)
+    {
+      impl_t::operator=(etl::move(other));
+
+      return *this;
+    }
+
+    //***************************************************************************
+    /// Move assignment operator from optional.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+      optional& operator =(optional&& other)
+    {
+      impl_t::operator=(etl::move(other));
+
+      return *this;
+    }
+#endif
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Assignment operator from value type.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional& operator =(const T& value_)
+    {
+      impl_t::operator=(value_);
+
+      return *this;
+    }
+
+    //***************************************************************************
+    /// Assignment operator from value type.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional& operator =(const T& value_)
+    {
+      impl_t::operator=(value_);
+
+      return *this;
+    }
+#else
+    //***************************************************************************
+    /// Assignment operator from value type.
+    //***************************************************************************
+    optional& operator =(const T& value_)
+    {
+      impl_t::operator=(value_);
+
+      return *this;
+    }
+#endif
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Move assignment operator from value type.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+      optional& operator =(T&& value_)
+    {
+      impl_t::operator=(etl::move(value_));
+
+      return *this;
+    }
+
+    //***************************************************************************
+    /// Move assignment operator from value type.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+      optional& operator =(T&& value_)
+    {
+      impl_t::operator=(etl::move(value_));
+
+      return *this;
+    }
+#endif
   };
 
 #include "private/diagnostic_uninitialized_push.h"
@@ -1122,7 +1560,7 @@ namespace etl
   /// Equality operator. cppreference 1
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     if (lhs.has_value() != rhs.has_value())
     {
@@ -1139,10 +1577,39 @@ namespace etl
   }
 
   //***************************************************************************
-  /// Equality operator. cppreference 2
+  /// Equality operator. cppreference 1
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator !=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    if (lhs.has_value() != rhs.has_value())
+    {
+      return false;
+    }
+    else if (!lhs.has_value() && !rhs.has_value())
+    {
+      return true;
+    }
+    else
+    {
+      return lhs.value() == rhs.value();
+    }
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 2
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 2
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     return !(lhs == rhs);
   }
@@ -1151,7 +1618,27 @@ namespace etl
   /// Less than operator. cppreference 3
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    if (!rhs.has_value())
+    {
+      return false;
+    }
+    else if (!lhs.has_value())
+    {
+      return true;
+    }
+    else
+    {
+      return lhs.value() < rhs.value();
+    }
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 3
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     if (!rhs.has_value())
     {
@@ -1171,7 +1658,16 @@ namespace etl
   /// Less than equal operator. cppreference 4
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    return !(rhs < lhs);
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 4
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     return !(rhs < lhs);
   }
@@ -1180,7 +1676,16 @@ namespace etl
   /// greater than operator. cppreference 5
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    return (rhs < lhs);
+  }
+
+  //***************************************************************************
+  /// greater than operator. cppreference 5
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     return (rhs < lhs);
   }
@@ -1189,7 +1694,16 @@ namespace etl
   /// greater than equal operator. cppreference 6
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    return !(lhs < rhs);
+  }
+
+  //***************************************************************************
+  /// greater than equal operator. cppreference 6
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     return !(lhs < rhs);
   }
@@ -1198,7 +1712,16 @@ namespace etl
   /// Equality operator. cppreference 7
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(const etl::optional<T>& lhs, etl::nullopt_t)
+  {
+    return !lhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Equality operator. cppreference 7
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(const etl::optional<T>& lhs, etl::nullopt_t)
   {
     return !lhs.has_value();
   }
@@ -1207,7 +1730,16 @@ namespace etl
   /// Equality operator. cppreference 8
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator ==(etl::nullopt_t, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(etl::nullopt_t, const etl::optional<T>& rhs)
+  {
+    return !rhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Equality operator. cppreference 8
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(etl::nullopt_t, const etl::optional<T>& rhs)
   {
     return !rhs.has_value();
   }
@@ -1216,7 +1748,16 @@ namespace etl
   /// Inequality operator. cppreference 9
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator !=(const etl::optional<T>& lhs, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(const etl::optional<T>& lhs, etl::nullopt_t)
+  {
+    return !(lhs == etl::nullopt);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 9
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(const etl::optional<T>& lhs, etl::nullopt_t)
   {
     return !(lhs == etl::nullopt);
   }
@@ -1225,7 +1766,16 @@ namespace etl
   /// Inequality operator. cppreference 10
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator !=(etl::nullopt_t , const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(etl::nullopt_t , const etl::optional<T>& rhs)
+  {
+    return !(etl::nullopt == rhs);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 10
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(etl::nullopt_t, const etl::optional<T>& rhs)
   {
     return !(etl::nullopt == rhs);
   }
@@ -1234,7 +1784,16 @@ namespace etl
   /// Less than operator. cppreference 11
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <(const etl::optional<T>&, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(const etl::optional<T>&, etl::nullopt_t)
+  {
+    return false;
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 11
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(const etl::optional<T>&, etl::nullopt_t)
   {
     return false;
   }
@@ -1243,7 +1802,16 @@ namespace etl
   /// Less than operator. cppreference 12
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <(etl::nullopt_t, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(etl::nullopt_t, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 12
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(etl::nullopt_t, const etl::optional<T>& rhs)
   {
     return rhs.has_value();
   }
@@ -1252,7 +1820,16 @@ namespace etl
   /// Less than equal operator. cppreference 13
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(const etl::optional<T>& lhs, etl::nullopt_t)
+  {
+    return !lhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 13
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(const etl::optional<T>& lhs, etl::nullopt_t)
   {
     return !lhs.has_value();
   }
@@ -1261,7 +1838,16 @@ namespace etl
   /// Less than equal operator. cppreference 14
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <=(etl::nullopt_t, const etl::optional<T>&)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(etl::nullopt_t, const etl::optional<T>&)
+  {
+    return true;
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 14
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(etl::nullopt_t, const etl::optional<T>&)
   {
     return true;
   }
@@ -1270,7 +1856,16 @@ namespace etl
   /// Greater than operator. cppreference 15
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(const etl::optional<T>& lhs, etl::nullopt_t)
+  {
+    return lhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Greater than operator. cppreference 15
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(const etl::optional<T>& lhs, etl::nullopt_t)
   {
     return lhs.has_value();
   }
@@ -1279,7 +1874,16 @@ namespace etl
   /// Greater than operator. cppreference 16
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >(etl::nullopt_t, const etl::optional<T>&)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(etl::nullopt_t, const etl::optional<T>&)
+  {
+    return false;
+  }
+
+  //***************************************************************************
+  /// Greater than operator. cppreference 16
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(etl::nullopt_t, const etl::optional<T>&)
   {
     return false;
   }
@@ -1288,7 +1892,16 @@ namespace etl
   /// Greater than equal operator. cppreference 17
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>&, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(const etl::optional<T>&, etl::nullopt_t)
+  {
+    return true;
+  }
+
+  //***************************************************************************
+  /// Greater than equal operator. cppreference 17
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(const etl::optional<T>&, etl::nullopt_t)
   {
     return true;
   }
@@ -1297,7 +1910,16 @@ namespace etl
   /// Greater than equal operator. cppreference 18
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >=(etl::nullopt_t, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(etl::nullopt_t, const etl::optional<T>& rhs)
+  {
+    return !rhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Greater than equal operator. cppreference 18
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(etl::nullopt_t, const etl::optional<T>& rhs)
   {
     return !rhs.has_value();
   }
@@ -1306,7 +1928,16 @@ namespace etl
   /// Equality operator. cppreference 19
   //**************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() == rhs : false;
+  }
+
+  //***************************************************************************
+  /// Equality operator. cppreference 19
+  //**************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() == rhs : false;
   }
@@ -1315,7 +1946,16 @@ namespace etl
   /// Inequality operator. cppreference 21
   //**************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator !=(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 21
+  //**************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(const etl::optional<T>& lhs, const U& rhs)
   {
     return !(lhs == rhs);
   }
@@ -1324,7 +1964,16 @@ namespace etl
   /// Equality operator. cppreference 20
   //**************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator ==(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? rhs.value() == lhs : false;
+  }
+
+  //***************************************************************************
+  /// Equality operator. cppreference 20
+  //**************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? rhs.value() == lhs : false;
   }
@@ -1333,7 +1982,16 @@ namespace etl
   /// Inequality operator. cppreference 22
   //**************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator !=(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 22
+  //**************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(const U& lhs, const etl::optional<T>& rhs)
   {
     return !(lhs == rhs);
   }
@@ -1342,7 +2000,16 @@ namespace etl
   /// Less than operator. cppreference 23
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator <(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() < rhs : true;
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 23
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() < rhs : true;
   }
@@ -1351,7 +2018,16 @@ namespace etl
   /// Less than operator. cppreference 24
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator <(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? lhs < rhs.value() : false;
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 24
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? lhs < rhs.value() : false;
   }
@@ -1360,7 +2036,16 @@ namespace etl
   /// Less than equal operator. cppreference 25
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() <= rhs : true;
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 25
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() <= rhs : true;
   }
@@ -1369,7 +2054,16 @@ namespace etl
   /// Less than equal operator. cppreference 26
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator <=(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? lhs <= rhs.value() : false;
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 26
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? lhs <= rhs.value() : false;
   }
@@ -1378,7 +2072,16 @@ namespace etl
   /// Greater than operator. cppreference 27
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() > rhs  : false;
+  }
+
+  //***************************************************************************
+  /// Greater than operator. cppreference 27
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() > rhs  : false;
   }
@@ -1387,7 +2090,16 @@ namespace etl
   /// Greater than operator. cppreference 28
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator >(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? lhs > rhs.value() : true;
+  }
+
+  //***************************************************************************
+  /// Greater than operator. cppreference 28
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? lhs > rhs.value() : true;
   }
@@ -1396,7 +2108,16 @@ namespace etl
   /// Greater than equal operator. cppreference 29
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() >= rhs : false;
+  }
+
+  //***************************************************************************
+  /// Greater than equal operator. cppreference 29
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() >= rhs : false;
   }
@@ -1405,7 +2126,16 @@ namespace etl
   /// Greater than equal operator. cppreference 30
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator >=(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? lhs >= rhs.value() : true;
+  }
+
+  //***************************************************************************
+  /// Greater than equal operator. cppreference 30
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? lhs >= rhs.value() : true;
   }
@@ -1416,7 +2146,7 @@ namespace etl
   /// Make an optional.
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 etl::optional<typename etl::decay<T>::type> make_optional(T& value)
+  ETL_CONSTEXPR20_STL etl::optional<typename etl::decay<T>::type> make_optional(T& value)
   {
     return etl::optional<typename etl::decay<T>::type>(value);
   }
@@ -1434,9 +2164,15 @@ namespace etl
 /// Swaps the values.
 //*************************************************************************
 template <typename T>
-ETL_CONSTEXPR14 void swap(etl::optional<T>& lhs, etl::optional<T>& rhs)
+ETL_CONSTEXPR20_STL void swap(etl::optional<T>& lhs, etl::optional<T>& rhs)
 {
   lhs.swap(rhs);
 }
 
+#undef ETL_OPTIONAL_ENABLE_CPP14
+#undef ETL_OPTIONAL_ENABLE_CPP20_STL
+
+#undef ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL
+#undef ETL_OPTIONAL_ENABLE_COMSTEXPR_BOOL_RETURN_CPP20_STL
+
 #endif
diff --git a/include/etl/platform.h b/include/etl/platform.h
index 294ee7cf..17c7961d 100644
--- a/include/etl/platform.h
+++ b/include/etl/platform.h
@@ -202,6 +202,14 @@ SOFTWARE.
   #define ETL_HAS_IDEQUE_REPAIR 0
 #endif
 
+//*************************************
+// Option to enable repair-after-memcpy for icircular_buffer.
+#if defined(ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE)
+#define ETL_HAS_ICIRCULAR_BUFFER_REPAIR 1
+#else
+#define ETL_HAS_ICIRCULAR_BUFFER_REPAIR 0
+#endif
+
 //*************************************
 // Indicate if C++ exceptions are enabled.
 #if defined(ETL_THROW_EXCEPTIONS)
@@ -249,7 +257,6 @@ SOFTWARE.
   #define ETL_CONSTEXPR                   constexpr
   #define ETL_CONSTEXPR11                 constexpr // Synonym for ETL_CONSTEXPR
   #define ETL_CONSTANT                    constexpr
-  #define ETL_STATIC_CONSTANT             constexpr
   #define ETL_DELETE                      = delete
   #define ETL_EXPLICIT                    explicit
   #define ETL_OVERRIDE                    override
@@ -271,7 +278,6 @@ SOFTWARE.
   #define ETL_CONSTEXPR
   #define ETL_CONSTEXPR11
   #define ETL_CONSTANT                    const
-  #define ETL_STATIC_CONSTANT             static const
   #define ETL_DELETE
   #define ETL_EXPLICIT
   #define ETL_OVERRIDE
@@ -479,6 +485,7 @@ namespace etl
     static ETL_CONSTANT bool has_string_clear_after_use       = (ETL_HAS_STRING_CLEAR_AFTER_USE == 1);
     static ETL_CONSTANT bool has_istring_repair               = (ETL_HAS_ISTRING_REPAIR == 1);
     static ETL_CONSTANT bool has_ivector_repair               = (ETL_HAS_IVECTOR_REPAIR == 1);
+    static ETL_CONSTANT bool has_icircular_buffer_repair      = (ETL_HAS_ICIRCULAR_BUFFER_REPAIR == 1);
     static ETL_CONSTANT bool has_mutable_array_view           = (ETL_HAS_MUTABLE_ARRAY_VIEW == 1);
     static ETL_CONSTANT bool has_ideque_repair                = (ETL_HAS_IDEQUE_REPAIR == 1);
     static ETL_CONSTANT bool has_virtual_messages             = (ETL_HAS_VIRTUAL_MESSAGES == 1);
diff --git a/include/etl/private/bitset_legacy.h b/include/etl/private/bitset_legacy.h
index 24052e41..593f415b 100644
--- a/include/etl/private/bitset_legacy.h
+++ b/include/etl/private/bitset_legacy.h
@@ -151,10 +151,10 @@ namespace etl
     typedef typename etl::make_unsigned<ETL_BITSET_ELEMENT_TYPE>::type element_type;
     typedef element_type element_t; // Backward compatibility
 
-    static ETL_CONSTANT element_type ALL_SET = etl::integral_limits<element_type>::max;
+    static ETL_CONSTANT element_type ALL_SET   = etl::integral_limits<element_type>::max;
     static ETL_CONSTANT element_type ALL_CLEAR = 0;
 
-    static ETL_CONSTANT size_t    Bits_Per_Element = etl::integral_limits<element_type>::bits;
+    static ETL_CONSTANT size_t       Bits_Per_Element  = etl::integral_limits<element_type>::bits;
 
 #if ETL_USING_CPP11
     typedef etl::span<element_type>       span_type;
@@ -311,7 +311,7 @@ namespace etl
     //*************************************************************************
     ibitset& set()
     {
-      ::memset(pdata, 0xFF, Number_Of_Elements);
+      etl::fill_n(pdata, Number_Of_Elements - 1U, ALL_SET);
       pdata[Number_Of_Elements - 1U] = Top_Mask;
 
       return *this;
@@ -429,7 +429,14 @@ namespace etl
     //*************************************************************************
     ibitset& set(const char* text)
     {
-      from_string(text);
+      if (text == ETL_NULLPTR)
+      {
+        reset();
+      }
+      else
+      {
+        from_string(text);
+      }
 
       return *this;
     }
@@ -439,7 +446,14 @@ namespace etl
     //*************************************************************************
     ibitset& set(const wchar_t* text)
     {
-      from_string(text);
+      if (text == ETL_NULLPTR)
+      {
+        reset();
+      }
+      else
+      {
+        from_string(text);
+      }
 
       return *this;
     }
@@ -449,7 +463,14 @@ namespace etl
     //*************************************************************************
     ibitset& set(const char16_t* text)
     {
-      from_string(text);
+      if (text == ETL_NULLPTR)
+      {
+        reset();
+      }
+      else
+      {
+        from_string(text);
+      }
 
       return *this;
     }
@@ -459,7 +480,14 @@ namespace etl
     //*************************************************************************
     ibitset& set(const char32_t* text)
     {
-      from_string(text);
+      if (text == ETL_NULLPTR)
+      {
+        reset();
+      }
+      else
+      {
+        from_string(text);
+      }
 
       return *this;
     }
@@ -491,7 +519,7 @@ namespace etl
       return v;
     }
 
-    //*************************************************************************
+    //************************************************************************* 
     /// Put to a unsigned long.
     //*************************************************************************
     unsigned long to_ulong() const
@@ -512,7 +540,7 @@ namespace etl
     //*************************************************************************
     ibitset& reset()
     {
-      ::memset(pdata, 0x00, Number_Of_Elements);
+      etl::fill_n(pdata, Number_Of_Elements, ALL_CLEAR);
 
       return *this;
     }
@@ -554,10 +582,10 @@ namespace etl
     //*************************************************************************
     ibitset& flip()
     {
-      for (size_t i = 0UL; i < Number_Of_Elements; ++i)
-      {
-        pdata[i] = ~pdata[i];
-      }
+      etl::transform_n(pdata, 
+                       Number_Of_Elements, 
+                       pdata, 
+                       etl::binary_not<element_type>());
 
       clear_unused_bits_in_msb();
 
@@ -832,7 +860,7 @@ namespace etl
             --dst_index;
 
             // Shift lsb.
-            element_type lsb = element_type((pdata[src_index] & lsb_mask) << lsb_shift);
+            lsb = element_type((pdata[src_index] & lsb_mask) << lsb_shift);
             pdata[dst_index] = lsb;
             --src_index;
           }
@@ -1194,7 +1222,6 @@ namespace etl
     //*************************************************************************
     bitset<MaxN>& set(const char* text)
     {
-      ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
       etl::ibitset::set(text);
 
       return *this;
@@ -1205,7 +1232,6 @@ namespace etl
     //*************************************************************************
     bitset<MaxN>& set(const wchar_t* text)
     {
-      ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
       etl::ibitset::set(text);
 
       return *this;
@@ -1216,7 +1242,6 @@ namespace etl
     //*************************************************************************
     bitset<MaxN>& set(const char16_t* text)
     {
-      ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
       etl::ibitset::set(text);
 
       return *this;
@@ -1227,7 +1252,6 @@ namespace etl
     //*************************************************************************
     bitset<MaxN>& set(const char32_t* text)
     {
-      ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
       etl::ibitset::set(text);
 
       return *this;
diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h
index 63462f21..cd9b28a9 100644
--- a/include/etl/private/bitset_new.h
+++ b/include/etl/private/bitset_new.h
@@ -45,11 +45,18 @@ SOFTWARE.
 #include "../error_handler.h"
 #include "../span.h"
 #include "../string.h"
+#include "../enum_type.h"
+#include "../largest.h"
+#include "../smallest.h"
 
 #include <string.h>
 #include <stddef.h>
 #include <stdint.h>
 
+#if ETL_USING_STL
+#include <algorithm>
+#endif
+
 #include "minmax_push.h"
 
 #if defined(ETL_COMPILER_KEIL)
@@ -76,14 +83,26 @@ SOFTWARE.
 
 namespace etl
 {
-  template <typename T = void>
-  struct bitset_constants
+  //***************************************************************************
+  /// Flags to indicate whether the bitset is contained in a single element
+  /// or spread over an array of elements.
+  ///\ingroup bitset
+  //***************************************************************************
+  struct bitset_storage_model
   {
-    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
-  };
+    enum enum_type
+    {
+      Undefined = 0,
+      Single    = 1,
+      Multi     = 2
+    };
 
-  template <typename T>
-  ETL_CONSTANT size_t bitset_constants<T>::npos;
+    ETL_DECLARE_ENUM_TYPE(bitset_storage_model, char)
+    ETL_ENUM_TYPE(Undefined, "Undefined")
+    ETL_ENUM_TYPE(Single,    "Single")
+    ETL_ENUM_TYPE(Multi,     "Multi")
+    ETL_END_ENUM_TYPE
+  };
 
   //***************************************************************************
   /// Exception base for bitset
@@ -127,87 +146,918 @@ namespace etl
     }
   };
 
-  //*************************************************************************
-  /// The implementation class for multi-element etl::bitset
+  //***************************************************************************
+  /// Bitset nullptr buffer exception.
   ///\ingroup bitset
-  //*************************************************************************
-  template <typename TElement>
-  class bitset_impl : public bitset_constants<>
+  //***************************************************************************
+  class bitset_invalid_buffer : public bitset_exception
   {
   public:
 
-    typedef typename etl::make_unsigned<TElement>::type element_type;
-
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
-
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
-
-    //*************************************************************************
-    /// Count the number of bits set.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t count(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT
+    bitset_invalid_buffer(string_type file_name_, numeric_type line_number_)
+      : bitset_exception(ETL_ERROR_TEXT("bitset:invalid buffer", ETL_BITSET_FILE_ID"D"), file_name_, line_number_)
     {
-      size_t n = 0UL;
+    }
+  };
 
-      for (size_t i = 0UL; i < number_of_elements; ++i)
+  //***************************************************************************
+  namespace private_bitset
+  {
+    template <typename TElement>
+    class bitset_impl_common
+    {
+    public:
+
+      typedef TElement        element_type;
+      typedef TElement*       pointer;
+      typedef const TElement* const_pointer;
+
+      static ETL_CONSTANT size_t   npos              = etl::integral_limits<size_t>::max;
+      static ETL_CONSTANT size_t   Bits_Per_Element  = etl::integral_limits<TElement>::bits;
+      static ETL_CONSTANT TElement All_Set_Element   = etl::integral_limits<TElement>::max;
+      static ETL_CONSTANT TElement All_Clear_Element = element_type(0);
+    };
+
+    template <typename TElement>
+    ETL_CONSTANT size_t bitset_impl_common<TElement>::npos;
+
+    template <typename TElement>
+    ETL_CONSTANT size_t bitset_impl_common<TElement>::Bits_Per_Element;
+
+    template <typename TElement>
+    ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Set_Element;
+
+    template <typename TElement>
+    ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Clear_Element;
+  }
+
+  //*************************************************************************
+  /// Bitset implementation declaration.
+  ///\ingroup bitset
+  //*************************************************************************
+  template <typename TElement, char Bitset_Layout>
+  class bitset_impl;
+
+  //*************************************************************************
+  /// The implementation class for single element etl::bitset
+  ///\ingroup bitset
+  //*************************************************************************
+  template <typename TElement>
+  class bitset_impl<TElement, etl::bitset_storage_model::Single> : public etl::private_bitset::bitset_impl_common<TElement>
+  {
+  public:
+
+    using typename etl::private_bitset::bitset_impl_common<TElement>::element_type;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::pointer;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::const_pointer;
+
+    using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
+
+    using etl::private_bitset::bitset_impl_common<TElement>::npos;
+
+    //*************************************************************************
+    /// Set all of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void set_all(pointer      pbuffer,
+                 size_t       /*number_of_elements*/,
+                 element_type top_mask) ETL_NOEXCEPT
+    {
+      *pbuffer = All_Set_Element & top_mask;
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer, 
+                      size_t  position, 
+                      bool    value = true)
+    {
+      const element_type mask = element_type(element_type(1) << position);
+
+      if (value == true)
       {
-        n += etl::count_bits(pbuffer[i]);
+        *pbuffer |= mask;
+      }
+      else
+      {
+        *pbuffer &= ~mask;
+      }
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer,
+                      bool    value = true)
+    {
+      const element_type mask = element_type(element_type(1) << Position);
+
+      if (value == true)
+      {
+        *pbuffer |= mask;
+      }
+      else
+      {
+        *pbuffer &= ~mask;
+      }
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer)
+    {
+      const element_type mask = element_type(element_type(1) << Position);
+
+      if (Value == true)
+      {
+        *pbuffer |= mask;
+      }
+      else
+      {
+        *pbuffer &= ~mask;
+      }
+    }
+
+    //*************************************************************************
+    /// Reset all of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void reset_all(pointer pbuffer, 
+                   size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Reset the bit at the position.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void reset_position(pointer pbuffer, 
+                        size_t  position)
+    {
+      const element_type mask = element_type(element_type(1) << position);
+      *pbuffer &= ~mask;
+    }
+
+    //*************************************************************************
+    /// Set from a string.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static 
+    void from_string(pointer     pbuffer, 
+                     size_t      /*number_of_elements*/, 
+                     size_t      active_bits, 
+                     const char* text) ETL_NOEXCEPT
+    {
+      reset_all(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
+      {
+        size_t string_length = etl::strlen(text);
+
+        // Build from the string.
+        string_length = etl::min(active_bits, string_length);
+
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
+        {
+          if (text[i] == ETL_STR('1'))
+          {
+            *pbuffer |= mask;
+          }
+
+          mask >>= 1U;
+        }
+      }
+    }
+
+    //*************************************************************************
+    /// Set from a wide string.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static 
+    void from_string(pointer        pbuffer, 
+                     size_t         /*number_of_elements*/, 
+                     size_t         active_bits, 
+                     const wchar_t* text) ETL_NOEXCEPT
+    {
+      reset_all(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
+      {
+        size_t string_length = etl::strlen(text);
+
+        // Build from the string.
+        string_length = etl::min(active_bits, string_length);
+
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
+        {
+          if (text[i] == ETL_STRL('1'))
+          {
+            *pbuffer |= mask;
+          }
+
+          mask >>= 1U;
+        }
+      }
+    }
+
+    //*************************************************************************
+    /// Set from a u16 string.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static 
+    void from_string(pointer         pbuffer, 
+                     size_t          /*number_of_elements*/, 
+                     size_t          active_bits, 
+                     const char16_t* text) ETL_NOEXCEPT
+    {
+      reset_all(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
+      {
+        size_t string_length = etl::strlen(text);
+
+        // Build from the string.
+        string_length = etl::min(active_bits, string_length);
+
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
+        {
+          if (text[i] == ETL_STRu('1'))
+          {
+            *pbuffer |= mask;
+          }
+
+          mask >>= 1U;
+        }
+      }
+    }
+
+    //*************************************************************************
+    /// Set from a u32 string.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void from_string(pointer         pbuffer, 
+                     size_t          /*number_of_elements*/, 
+                     size_t          active_bits, 
+                     const char32_t* text) ETL_NOEXCEPT
+    {
+      reset_all(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
+      {
+        size_t string_length = etl::strlen(text);
+
+        // Build from the string.
+        string_length = etl::min(active_bits, string_length);
+
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
+        {
+          if (text[i] == ETL_STRU('1'))
+          {
+            *pbuffer |= mask;
+          }
+
+          mask >>= 1U;
+        }
+      }
+    }
+
+    //*************************************************************************
+    /// Get as an integral value.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    static
+    T value(const_pointer pbuffer, 
+            size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return T(*pbuffer);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    static
+    T extract(const_pointer pbuffer, 
+              size_t        position, 
+              size_t        length = etl::integral_limits<T>::bits)
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      const unsigned_t Mask  = etl::make_lsb_mask<unsigned_t>(length);
+      const unsigned_t Shift = position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
       }
 
-      return n;
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    //*************************************************************************
+#if ETL_USING_CPP11
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#else
+		template <typename T, size_t Position, size_t Length>
+#endif
+    ETL_CONSTEXPR14
+    static
+    T extract(const_pointer pbuffer)
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      const unsigned_t Mask  = etl::make_lsb_mask<unsigned_t>(Length);
+      const unsigned_t Shift = Position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, Length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
     /// Tests a bit at a position.
     /// Positions greater than the number of configured bits will return <b>false</b>.
     //*************************************************************************
-    ETL_CONSTEXPR14 bool test(const_pointer pbuffer, size_t number_of_elements, size_t position) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 
+    static 
+    bool test(const_pointer pbuffer, 
+              size_t        position)
     {
-      size_t       index = 0U;
-      element_type mask  = element_type(0);
+      const element_type mask = element_type(element_type(1) << position);
+      return (*pbuffer & mask) != 0U;
+    }
 
-      if (number_of_elements == 1U)
+    //*************************************************************************
+    /// Count the number of bits set.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    size_t count(const_pointer pbuffer, 
+                 size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return etl::count_bits(*pbuffer);
+    }
+
+    //*************************************************************************
+    // Are all the bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    bool all(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/, 
+             element_type  top_mask) ETL_NOEXCEPT
+    {
+      return (*pbuffer & top_mask) == top_mask;
+    }
+
+    //*************************************************************************
+    // Are all the mask bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool all(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/, 
+             element_type  top_mask, 
+             element_type  mask) ETL_NOEXCEPT
+    {
+      return (*pbuffer & top_mask & mask) == mask;
+    }
+
+    //*************************************************************************
+    /// Are none of the bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool none(const_pointer pbuffer, 
+              size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return *pbuffer == All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Are none of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool none(const_pointer pbuffer, 
+              size_t        /*number_of_elements*/, 
+              element_type  mask) ETL_NOEXCEPT
+    {
+      return (*pbuffer & mask) == All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Are any of the bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool any(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return *pbuffer != All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Are any of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    bool any(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/, 
+             element_type  mask) ETL_NOEXCEPT
+    {
+      return (*pbuffer & mask) != All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Flip all of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void flip_all(pointer pbuffer, 
+                     size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = ~*pbuffer;
+    }
+
+    //*************************************************************************
+    /// Flip some of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void flip_bits(pointer      pbuffer, 
+                   element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
+    {
+      *pbuffer ^= mask;
+    }
+
+    //*************************************************************************
+    /// Flip the bit at the position.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void flip_position(pointer pbuffer, 
+                       size_t  position)
+    {
+      const element_type mask = element_type(element_type(1) << position);
+      *pbuffer ^= mask;
+    }
+
+    //*************************************************************************
+    /// Returns a string representing the bitset.
+    //*************************************************************************
+    template <typename TString>
+    ETL_CONSTEXPR14 
+    static 
+    TString to_string(const_pointer pbuffer,
+                      size_t active_bits,
+                      typename TString::value_type zero = typename TString::value_type('0'),
+                      typename TString::value_type one  = typename TString::value_type('1'))
+    {
+      TString result;
+
+      result.resize(active_bits, '\0');
+
+      // Check that the string type can contain the digits.
+      ETL_ASSERT_OR_RETURN_VALUE(result.size() == active_bits, ETL_ERROR(etl::bitset_string_too_small), result);
+
+      for (size_t i = active_bits; i > 0; --i)
       {
-        index = 0;
-        mask = element_type(1) << position;
+        result[active_bits - i] = test(pbuffer, i - 1) ? one : zero;
+      }
+
+      return result;
+    }
+
+    //*************************************************************************
+    /// Finds the next bit in the specified state.
+    ///\param state    The state to search for.
+    ///\param position The position to start from.
+    ///\returns The position of the bit or npos if none were found.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    size_t find_next(const_pointer pbuffer, 
+                     size_t        /*number_of_elements*/, 
+                     size_t        active_bits, 
+                     bool          state, 
+                     size_t        position) ETL_NOEXCEPT
+    {
+      if (position < active_bits)
+      {
+        // Where to start.
+        size_t bit = position;
+
+        element_type mask = 1U << position;
+
+        // Needs checking?
+        if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element)))
+        {
+          // For each bit in the element...
+          while (bit < active_bits)
+          {
+            // Equal to the required state?
+            if (((*pbuffer & mask) != 0) == state)
+            {
+              return bit;
+            }
+
+            // Move on to the next bit.
+            mask <<= 1;
+            ++bit;
+          }
+        }
+      }
+
+      return npos;
+    }
+
+    //*************************************************************************
+    /// operator assignment
+    /// Assigns rhs to lhs
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_assignment(pointer       lhs_pbuffer, 
+                             const_pointer rhs_pbuffer, 
+                             size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer = *rhs_pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator and
+    /// AND lhs and rhs and put the result in lhs
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_and(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer &= *rhs_pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator or
+    /// OR lhs and rhs and put the result in lhs
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_or(pointer       lhs_pbuffer, 
+                     const_pointer rhs_pbuffer, 
+                     size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer |= *rhs_pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator xor
+    /// XOR lhs and rhs and put the result in lhs
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_xor(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer ^= *rhs_pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator ~
+    /// NOT the value in the buffer
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_not(pointer pbuffer, 
+                      size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = ~*pbuffer;
+    }
+
+    //*************************************************************************
+    /// operator_shift_left
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_shift_left(pointer pbuffer, 
+                             size_t  /*number_of_elements*/, 
+                             size_t  active_bits, 
+                             size_t  shift) ETL_NOEXCEPT
+    {
+      if (shift >= active_bits)
+      {
+        reset_all(pbuffer, 1U);
       }
       else
       {
-        index = position >> etl::log2<Bits_Per_Element>::value;
-        mask = element_type(1) << (position & (Bits_Per_Element - 1));
+        *pbuffer <<= shift;
       }
+    }
+
+    //*************************************************************************
+    /// operator_shift_right
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static 
+    void operator_shift_right(pointer pbuffer, 
+                              size_t  /*number_of_elements*/, 
+                              size_t  active_bits, 
+                              size_t  shift) ETL_NOEXCEPT
+    {
+      if (shift >= active_bits)
+      {
+        reset_all(pbuffer, 1U);
+      }
+      else
+      {
+        *pbuffer >>= shift;
+      }
+    }
+
+    //*************************************************************************
+    /// operator_equality
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static
+    bool operator_equality(const_pointer lhs_pbuffer, 
+                           const_pointer rhs_pbuffer, 
+                           size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return (*lhs_pbuffer == *rhs_pbuffer);
+    }
+
+    //*************************************************************************
+    /// Initialise from an unsigned long long.
+    //*************************************************************************
+    template <typename TElementType>
+    ETL_CONSTEXPR14 
+    static 
+    void initialise(pointer            pbuffer, 
+                    size_t             /*number_of_elements*/,
+                    unsigned long long value) ETL_NOEXCEPT
+    {
+      *pbuffer = static_cast<TElementType>(value);
+    }
+
+    //*************************************************************************
+    /// swap
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static
+    void swap(pointer lhs_pbuffer, 
+              pointer rhs_pbuffer, 
+              size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      element_type temp = *lhs_pbuffer;
+      *lhs_pbuffer = *rhs_pbuffer;
+      *rhs_pbuffer = temp;
+    }
+  };
+
+  //*************************************************************************
+  /// The implementation class for multi element etl::bitset
+  ///\ingroup bitset
+  //*************************************************************************
+  template <typename TElement>
+  class bitset_impl<TElement, etl::bitset_storage_model::Multi> : public etl::private_bitset::bitset_impl_common<TElement>
+  {
+  private:
+
+    typedef etl::private_bitset::bitset_impl_common<TElement> common;
+
+  public:
+
+    using typename etl::private_bitset::bitset_impl_common<TElement>::element_type;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::pointer;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::const_pointer;
+
+    using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
+
+    using etl::private_bitset::bitset_impl_common<TElement>::npos;
+
+    //*************************************************************************
+    /// Check to see if the requested extract is contained within one element.
+    //*************************************************************************
+    template <size_t Position, size_t Length, size_t Bits_Per_Element>
+    struct value_is_in_one_element
+    {
+      static ETL_CONSTANT bool value = ((Position + Length - 1) >> etl::log2<Bits_Per_Element>::value) == (Position >> etl::log2<Bits_Per_Element>::value);
+    };
+
+    //*************************************************************************
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will return <b>false</b>.
+    //*************************************************************************
+    ETL_CONSTEXPR14 
+    static
+    bool test(const_pointer pbuffer,
+              size_t        position) ETL_NOEXCEPT
+    {
+      size_t index      = position >> etl::log2<Bits_Per_Element>::value;
+      element_type mask = element_type(1) << (position & (Bits_Per_Element - 1));
 
       return (pbuffer[index] & mask) != 0;
     }
 
+    //*************************************************************************
+    /// Count the number of bits set.
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    size_t count(const_pointer pbuffer,
+                 size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      size_t count = 0;
+
+      while (number_of_elements-- != 0)
+      {
+        count += etl::count_bits(*pbuffer++);
+      }
+
+      return count;
+    }
+
+    //*************************************************************************
+    // Are all the bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    bool all(const_pointer pbuffer,
+             size_t        number_of_elements,
+             element_type  top_mask) ETL_NOEXCEPT
+    {
+      // All but the last.
+      while (number_of_elements-- != 1U)
+      {
+        if (*pbuffer++ != All_Set_Element)
+        {
+          return false;
+        }
+      }
+
+      // The last.
+      if ((*pbuffer & top_mask) != top_mask)
+      {
+        return false;
+      }
+
+      return true;
+    }
+
+    //*************************************************************************
+    /// Are none of the bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14
+      static
+      bool none(const_pointer pbuffer,
+                size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
+      {
+        if (*pbuffer++ != 0)
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    //*************************************************************************
+    /// Are any of the bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    bool any(const_pointer pbuffer,
+             size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      bool any_set = false;
+
+      while (number_of_elements-- != 0)
+      {
+        if (*pbuffer++ != All_Clear_Element)
+        {
+          any_set = true;
+          break;
+        }
+      }
+
+      return any_set;
+    }
+
+    //*************************************************************************
+    /// Set all bits
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void set_all(pointer      pbuffer,
+                 size_t       number_of_elements,
+                 element_type top_mask) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 1U)
+      {
+        *pbuffer++ = All_Set_Element;
+      }
+
+      *pbuffer = (All_Set_Element & top_mask);
+    }
 
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t position, bool value = true) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer, 
+                      size_t  position, 
+                      bool    value = true) ETL_NOEXCEPT
     {
-      size_t    index = 0;
-      element_type bit = 0;
+      size_t       index = position >> etl::log2<Bits_Per_Element>::value;
+      element_type bit   = element_type(1) << (position & (Bits_Per_Element - 1));
 
-      if (number_of_elements == 0)
+      if (value == true)
       {
-        return;
-      }
-      else if (number_of_elements == 1U)
-      {
-        index = 0;
-        bit = element_type(1) << position;
+        pbuffer[index] |= bit;
       }
       else
       {
-        index = position >> etl::log2<Bits_Per_Element>::value;
-        bit = element_type(1) << (position & (Bits_Per_Element - 1));
+        pbuffer[index] &= ~bit;
       }
+    }
 
-      if (value)
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer,
+                      bool    value = true)
+    {
+      size_t       index = Position >> etl::log2<Bits_Per_Element>::value;
+      element_type bit   = element_type(1) << (Position & (Bits_Per_Element - 1));
+
+      if (value == true)
+      {
+        pbuffer[index] |= bit;
+      }
+      else
+      {
+        pbuffer[index] &= ~bit;
+      }
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14
+    static
+    void set_position(pointer pbuffer)
+    {
+      size_t       index = Position >> etl::log2<Bits_Per_Element>::value;
+      element_type bit = element_type(1) << (Position & (Bits_Per_Element - 1));
+
+      if (Value == true)
       {
         pbuffer[index] |= bit;
       }
@@ -220,7 +1070,12 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 
+    static 
+    void from_string(pointer     pbuffer, 
+                     size_t      number_of_elements, 
+                     size_t      total_bits, 
+                     const char* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
@@ -229,12 +1084,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -242,7 +1097,7 @@ namespace etl
 
         while (i > 0)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STR('1'));
+          set_position(pbuffer, --i, *text++ == ETL_STR('1'));
         }
       }
     }
@@ -250,7 +1105,12 @@ namespace etl
     //*************************************************************************
     /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void from_string(pointer        pbuffer, 
+                     size_t         number_of_elements, 
+                     size_t         total_bits, 
+                     const wchar_t* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
@@ -259,12 +1119,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -272,7 +1132,7 @@ namespace etl
 
         while (i > 0)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STRL('1'));
+          set_position(pbuffer, --i, *text++ == ETL_STRL('1'));
         }
       }
     }
@@ -280,7 +1140,12 @@ namespace etl
     //*************************************************************************
     /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void from_string(pointer         pbuffer, 
+                     size_t          number_of_elements, 
+                     size_t          total_bits, 
+                     const char16_t* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
@@ -289,12 +1154,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -302,7 +1167,7 @@ namespace etl
 
         while (i > 0)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STRu('1'));
+          set_position(pbuffer, --i, *text++ == ETL_STRu('1'));
         }
       }
     }
@@ -310,7 +1175,12 @@ namespace etl
     //*************************************************************************
     /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void from_string(pointer         pbuffer, 
+                     size_t          number_of_elements, 
+                     size_t          total_bits, 
+                     const char32_t* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
@@ -319,12 +1189,12 @@ namespace etl
       else
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
         // Only reset elements we need to.
-        while (element_index != number_of_elements)
+        while (index != number_of_elements)
         {
-          pbuffer[element_index++] = All_Clear_Element;
+          pbuffer[index++] = All_Clear_Element;
         }
 
         // Build from the string.
@@ -332,41 +1202,37 @@ namespace etl
 
         while (i > 0)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STRU('1'));
+          set_position(pbuffer, --i, *text++ == ETL_STRU('1'));
         }
       }
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Reset all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void reset_all(pointer pbuffer,
+                   size_t  number_of_elements) ETL_NOEXCEPT
     {
-      from_string(pbuffer, number_of_elements, total_bits, text);
+      while (number_of_elements-- != 0U)
+      {
+        *pbuffer++ = All_Clear_Element;
+      }
     }
 
     //*************************************************************************
-    /// Set from a wstring.
+    /// Reset the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void reset_position(pointer pbuffer, 
+                        size_t  position) ETL_NOEXCEPT
     {
-      from_string(pbuffer, number_of_elements, total_bits, text);
-    }
+      const size_t       index = position >> etl::log2<Bits_Per_Element>::value;;
+      const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1));
 
-    //*************************************************************************
-    /// Set from a u16string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT
-    {
-      from_string(pbuffer, number_of_elements, total_bits, text);
-    }
-
-    //*************************************************************************
-    /// Set from a u32string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT
-    {
-      from_string(pbuffer, number_of_elements, total_bits, text);
+      pbuffer[index] &= ~bit;
     }
 
     //*************************************************************************
@@ -374,8 +1240,9 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT
+    static
+    T value(const_pointer pbuffer, 
+            size_t        number_of_elements) ETL_NOEXCEPT
     {
       T v = T(0);
 
@@ -396,129 +1263,214 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Reset the bit at the position.
+    /// Extract an value from multiple elements.
     //*************************************************************************
-    ETL_CONSTEXPR14 void reset(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT
+    template <typename T>
+    ETL_CONSTEXPR14
+    static 
+    typename etl::make_unsigned<T>::type extract_from_multiple_elements(const element_type* pbuffer,
+                                                                        int                 element_index,
+                                                                        size_t              active_bits_in_msb,
+                                                                        size_t              length) ETL_NOEXCEPT
     {
-      size_t       index = 0U;
-      element_type bit = element_type(0);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      if (number_of_elements == 0)
+      unsigned_t value(0);
+
+      // Extract the first element, if partially filled.
+      if (active_bits_in_msb < Bits_Per_Element)
       {
-        return;
+        element_type mask = etl::make_lsb_mask< element_type>(active_bits_in_msb);
+        value = pbuffer[element_index] & mask;
+        length -= active_bits_in_msb;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
       }
-      else if (number_of_elements == 1)
+
+      // Loop through the fully filled elements
+      while (length >= Bits_Per_Element)
       {
-        index = 0;
-        bit = element_type(1) << position;
+        value |= pbuffer[element_index];
+        length -= Bits_Per_Element;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
+      }
+
+      // Extract the last element, if partially filled.
+      if (length != 0)
+      {
+        value = value << length;
+        element_type mask = etl::make_lsb_mask< element_type>(length);
+        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
+      }
+
+      return value;
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    /// Run time position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    static
+    typename etl::make_unsigned<T>::type extract_from_buffer(const_pointer pbuffer, 
+                                                             size_t        position, 
+                                                             size_t        length) ETL_NOEXCEPT
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value(0);
+
+      const int Msb_Element_Index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const int Lsb_Element_Index = position >> etl::log2<Bits_Per_Element>::value;
+
+      // Is the value contained within one element?
+      if (Msb_Element_Index == Lsb_Element_Index)
+      {
+        const unsigned_t Mask  = etl::make_lsb_mask< unsigned_t>(length);
+        const unsigned_t Shift = position % Bits_Per_Element;
+
+        value = static_cast<unsigned_t>(pbuffer[Msb_Element_Index] >> Shift) & Mask;
       }
       else
       {
-        index = position >> etl::log2<Bits_Per_Element>::value;
-        bit = element_type(1) << (position & (Bits_Per_Element - 1));
+        // Get the number of active bits in the msb element 
+        size_t active_bits_in_msb = (position + length) - (Msb_Element_Index * Bits_Per_Element);
+
+        // Start with index of the element containing the msb.
+        int element_index = Msb_Element_Index;
+
+        value = extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
       }
 
-      pbuffer[index] &= ~bit;
+      return value;
+    }
+
+    //*************************************************************************
+    /// Extract an integral value when the value fits in one element.
+    /// Compile time position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length>
+    ETL_CONSTEXPR14
+    static
+    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
+      extract_from_buffer(const_pointer pbuffer)
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      const int        Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const unsigned_t Mask          = etl::lsb_mask<unsigned_t, Length>::value;
+      const unsigned_t Shift         = Position % Bits_Per_Element;
+      
+      return  static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
+    }
+
+    //*************************************************************************
+    /// Extract an integral value when the value spans more than one element.
+    /// Compile time position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length>
+    ETL_CONSTEXPR14
+    static
+    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
+      extract_from_buffer(const_pointer pbuffer)
+    {      
+      // Start with index of the element containing the msb.
+      const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+
+      // Get the number of active bits in the first element 
+      const size_t Active_Bits_In_Msb = ((Position + Length - 1) % Bits_Per_Element) + 1;
+
+      return extract_from_multiple_elements<T>(pbuffer, Msb_Element_Index, Active_Bits_In_Msb, Length);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    static
+    T extract(const_pointer pbuffer,
+              size_t        position,
+              size_t        length = etl::integral_limits<T>::bits)
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = extract_from_buffer<unsigned_t>(pbuffer, position, length);
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    //*************************************************************************
+    template <typename T, size_t Position, size_t Length>
+    ETL_CONSTEXPR14
+    static
+    T extract(const_pointer pbuffer)
+    {
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = extract_from_buffer<unsigned_t, Position, Length>(pbuffer);
+
+      if ((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, Length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
     /// Flip all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void flip_all(pointer pbuffer, 
+                     size_t  number_of_elements) ETL_NOEXCEPT
     {
-      for (size_t i = 0UL; i < number_of_elements; ++i)
-      {
-        pbuffer[i] = ~pbuffer[i];
-      }
+      operator_not(pbuffer, number_of_elements);
     }
 
     //*************************************************************************
     /// Flip the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void flip_position(pointer pbuffer, 
+                       size_t  position) ETL_NOEXCEPT
     {
-      size_t       index = 0U;
-      element_type bit = element_type(0);
-      
-      if (number_of_elements == 0)
-      {
-        return;
-      }
-      else if (number_of_elements == 1)
-      {
-        index = 0;
-        bit = element_type(1) << position;
-      }
-      else
-      {
-        index = position >> log2<Bits_Per_Element>::value;
-        bit = element_type(1) << (position & (Bits_Per_Element - 1));
-      }
+      const size_t       index = position >> etl::log2<Bits_Per_Element>::value;;
+      const element_type bit   = element_type(1) << (position & (Bits_Per_Element - 1));
 
       pbuffer[index] ^= bit;
     }
 
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all(const_pointer pbuffer, size_t number_of_elements, element_type top_mask) const ETL_NOEXCEPT
-    {
-      if (number_of_elements == 0UL)
-      {
-        return true;
-      }
-
-      // All but the last.
-      for (size_t i = 0UL; i < (number_of_elements - 1U); ++i)
-      {
-        if (pbuffer[i] != All_Set_Element)
-        {
-          return false;
-        }
-      }
-
-      // The last.
-      if (pbuffer[number_of_elements - 1U] != (All_Set_Element & top_mask))
-      {
-        return false;
-      }
-
-      return true;
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT
-    {
-      for (size_t i = 0UL; i < number_of_elements; ++i)
-      {
-        if (pbuffer[i] != 0)
-        {
-          return false;
-        }
-      }
-
-      return true;
-    }
-
-    //*************************************************************************
-    /// Finds the first bit in the specified state.
-    ///\param state The state to search for.
-    ///\returns The position of the bit or Number_Of_Elements if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_first(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state) const ETL_NOEXCEPT
-    {
-      return find_next(pbuffer, number_of_elements, total_bits, state, 0);
-    }
-
     //*************************************************************************
     /// Finds the next bit in the specified state.
     ///\param state    The state to search for.
     ///\param position The position to start from.
     ///\returns The position of the bit or npos if none were found.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_next(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state, size_t position) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    size_t find_next(const_pointer pbuffer, 
+                     size_t        number_of_elements, 
+                     size_t        total_bits, 
+                     bool          state, 
+                     size_t        position) ETL_NOEXCEPT
     {
       // Where to start.
       size_t index = position >> log2<Bits_Per_Element>::value;
@@ -569,11 +1521,12 @@ namespace etl
     /// Returns a string representing the bitset.
     //*************************************************************************
     template <typename TString>
-    ETL_CONSTEXPR14 TString to_string(const_pointer                pbuffer,
-                                      size_t                       number_of_elements, 
-                                      size_t                       active_bits, 
-                                      typename TString::value_type zero, 
-                                      typename TString::value_type one) const
+    ETL_CONSTEXPR14
+    static
+    TString to_string(const_pointer                pbuffer,
+                      size_t                       active_bits, 
+                      typename TString::value_type zero, 
+                      typename TString::value_type one)
     {
       TString result;
 
@@ -584,28 +1537,108 @@ namespace etl
 
       for (size_t i = active_bits; i > 0; --i)
       {
-        result[active_bits - i] = test(pbuffer, number_of_elements, i - 1) ? one : zero;
+        result[active_bits - i] = test(pbuffer, i - 1) ? one : zero;
       }
 
       return result;
     }
 
     //*************************************************************************
-    /// shift_left_equals
+    /// operator assignment
     //*************************************************************************
-    ETL_CONSTEXPR14 void shift_left_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void operator_assignment(pointer       lhs_pbuffer, 
+                             const_pointer rhs_pbuffer, 
+                             size_t        number_of_elements) ETL_NOEXCEPT
     {
-      if (number_of_elements == 1U)
+      while (number_of_elements-- != 0)
       {
-        // Just one element.
-        pbuffer[0] <<= shift;
+        *lhs_pbuffer = *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
       }
-      else if ((shift % Bits_Per_Element) == 0U)
+    }
+
+    //*************************************************************************
+    /// operator and
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_and(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
       {
-        // Shift by whole element.
-        const size_t element_shift = shift / Bits_Per_Element;
-        etl::copy_backward(pbuffer, pbuffer + number_of_elements - element_shift, pbuffer + number_of_elements);
-        etl::fill_n(pbuffer, element_shift, All_Clear_Element);
+        *lhs_pbuffer &= *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
+      }
+    }
+
+    //*************************************************************************
+    /// operator or
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_or(pointer       lhs_pbuffer, 
+                     const_pointer rhs_pbuffer, 
+                     size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
+      {
+        *lhs_pbuffer |= *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
+      }
+    }
+
+    //*************************************************************************
+    /// operator xor
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_xor(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
+      {
+        *lhs_pbuffer ^= *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
+      }
+    }
+
+    //*************************************************************************
+    /// operator not
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_not(pointer pbuffer, 
+                      size_t  number_of_elements) ETL_NOEXCEPT
+    {
+      while (number_of_elements-- != 0)
+      {
+        *pbuffer = ~*pbuffer;
+        ++pbuffer;
+      }
+    }
+
+    //*************************************************************************
+    /// operator_shift_left
+    //*************************************************************************
+    ETL_CONSTEXPR14
+    static
+    void operator_shift_left(pointer pbuffer, 
+                             size_t  number_of_elements, 
+                             size_t  active_bits, 
+                             size_t  shift) ETL_NOEXCEPT
+    {
+      if (shift >= active_bits)
+      {
+        reset_all(pbuffer, number_of_elements);
       }
       else
       {
@@ -622,10 +1655,10 @@ namespace etl
         const size_t lsb_shift = Bits_Per_Element - split_position;
         const size_t msb_shift = split_position;
 
-        const element_type lsb_mask         = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
-        const element_type msb_mask         = etl::integral_limits<element_type>::max - lsb_mask;
+        const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
+        const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
         const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift);
-          
+
         // First lsb.
         element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
         pbuffer[dst_index] = lsb;
@@ -640,7 +1673,7 @@ namespace etl
           --dst_index;
 
           // Shift lsb.
-          element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
+          lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
           pbuffer[dst_index] = lsb;
           --src_index;
         }
@@ -648,7 +1681,6 @@ namespace etl
         // Clear the remaining bits.
         // First lsb.
         pbuffer[dst_index] &= lsb_shifted_mask;
-//        --dst_index;
 
         // The other remaining bytes on the right.
         for (int i = 0; i < dst_index; ++i)
@@ -659,21 +1691,18 @@ namespace etl
     }
 
     //*************************************************************************
-    /// shift_right_equals
+    /// operator_shift_right
     //*************************************************************************
-    ETL_CONSTEXPR14 void shift_right_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    void operator_shift_right(pointer pbuffer, 
+                              size_t  number_of_elements, 
+                              size_t  active_bits, 
+                              size_t  shift) ETL_NOEXCEPT
     {
-      if (number_of_elements == 1U)
+      if (shift >= active_bits)
       {
-        // Just one element.
-        pbuffer[0] >>= shift;
-      }
-      else if ((shift % Bits_Per_Element) == 0U)
-      {
-        // Shift by whole elements.
-        const size_t element_shift = (shift / Bits_Per_Element);
-        pointer pzeros_begin = etl::copy(pbuffer + element_shift, pbuffer + number_of_elements, pbuffer);      
-        etl::fill_n(pzeros_begin, element_shift, All_Clear_Element);
+        reset_all(pbuffer, number_of_elements);
       }
       else
       {
@@ -690,8 +1719,8 @@ namespace etl
         const size_t lsb_shift = Bits_Per_Element - split_position;
         const size_t msb_shift = split_position;
 
-        const element_type lsb_mask         = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
-        const element_type msb_mask         = etl::integral_limits<element_type>::max - lsb_mask;
+        const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
+        const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
         const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift);
 
         // Now do the shifting.
@@ -700,10 +1729,10 @@ namespace etl
           // Shift msb.
           element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
           ++src_index;
-            
+
           // Shift lsb.
           element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
-            
+
           // Combine them.
           pbuffer[dst_index] = lsb | msb;
           ++dst_index;
@@ -728,1023 +1757,193 @@ namespace etl
     }
 
     //*************************************************************************
-    /// and_equals
+    /// operator_equality
     //*************************************************************************
-    ETL_CONSTEXPR14 void and_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+    static
+    bool operator_equality(const_pointer lhs_pbuffer, 
+                           const_pointer rhs_pbuffer, 
+                           size_t        number_of_elements) ETL_NOEXCEPT
     {
-      for (size_t i = 0U; i < number_of_elements; ++i)
-      {
-        pbuffer[i] &= pbuffer2[i];
-      }
+      return etl::equal(lhs_pbuffer, lhs_pbuffer + number_of_elements, rhs_pbuffer);
     }
 
     //*************************************************************************
-    /// or_equals
+    /// Initialise from an unsigned long long.
+    /// Enabled if the number of bits in the element equals the number of bits in an unsigned long long.
     //*************************************************************************
-    ETL_CONSTEXPR14 void or_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT
+    template <typename TElementType>
+    ETL_CONSTEXPR14
+    static
+    typename etl::enable_if<etl::integral_limits<TElementType>::bits == etl::integral_limits<unsigned long long>::bits, void>::type
+      initialise(pointer            pbuffer, 
+                 size_t             number_of_elements, 
+                 unsigned long long value) ETL_NOEXCEPT
     {
-      for (size_t i = 0U; i < number_of_elements; ++i)
-      {
-        pbuffer[i] |= pbuffer2[i];
-      }
-    }
+      size_t i = 0UL;
+      
+      // Set the non-zero elements.
+      pbuffer[i++] = value;
 
-    //*************************************************************************
-    /// xor_equals
-    //*************************************************************************
-    ETL_CONSTEXPR14 void xor_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT
-    {
-      for (size_t i = 0U; i < number_of_elements; ++i)
+      // Clear the remaining elements.
+      while (i != number_of_elements)
       {
-        pbuffer[i] ^= pbuffer2[i];
+        pbuffer[i++] = All_Clear_Element;
       }
     }
 
     //*************************************************************************
     /// Initialise from an unsigned long long.
+    /// Enabled if the number of bits in the element doesn't equal the number of bits in an unsigned long long.
     //*************************************************************************
-    ETL_CONSTEXPR14 void initialise(pointer pbuffer, size_t number_of_elements, unsigned long long value) ETL_NOEXCEPT
+    template <typename TElementType>
+    ETL_CONSTEXPR14
+    static
+    typename etl::enable_if<etl::integral_limits<TElementType>::bits != etl::integral_limits<unsigned long long>::bits, void>::type
+      initialise(pointer            pbuffer,
+                 size_t             number_of_elements,
+                 unsigned long long value) ETL_NOEXCEPT
     {
-      const size_t Shift = (etl::integral_limits<unsigned long long>::bits <= (int)Bits_Per_Element) ? 0 : Bits_Per_Element;
+      size_t i = 0UL;
 
-      // Can we do it in one hit?
-      if (Shift == 0)
+      // Set the non-zero elements.
+      const unsigned long long Shift = etl::integral_limits<element_type>::bits;
+
+      while ((value != 0) && (i != number_of_elements))
       {
-        pbuffer[0] = element_type(value);
+        pbuffer[i++] = value & All_Set_Element;
+        value = value >> Shift;
       }
-      else
+
+      // Clear the remaining elements.
+      while (i != number_of_elements)
       {
-        size_t i = 0UL;
-
-        // Set the non-zero elements.
-        while ((value != 0) && (i != number_of_elements))
-        {
-          pbuffer[i++] = value & All_Set_Element;
-          value = value >> Shift;
-        }
-
-        // Clear the remaining elements.
-        while (i != number_of_elements)
-        {
-          pbuffer[i++] = All_Clear_Element;
-        }
+        pbuffer[i++] = All_Clear_Element;
       }
     }
 
     //*************************************************************************
     /// Swap bitset buffers.
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(pointer pbuffer1, pointer pbuffer2, size_t number_of_elements)
+    ETL_CONSTEXPR14
+    static
+    void swap(pointer pbuffer1, 
+              pointer pbuffer2, 
+              size_t  number_of_elements)
     {
-      const pointer pbuffer1_end = pbuffer1 + number_of_elements;
-
-      while (pbuffer1 != pbuffer1_end)
-      {
-        element_type temp = *pbuffer1;
-        *pbuffer1 = *pbuffer2;
-        *pbuffer2 = temp;
-        ++pbuffer1;
-        ++pbuffer2;
-      }
+      etl::swap_ranges(pbuffer1, pbuffer1 + number_of_elements, pbuffer2);
     }
   };
- 
-  template <typename TElement>
-  ETL_CONSTANT size_t bitset_impl<TElement>::Bits_Per_Element;
 
-  template <typename TElement>
-  ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Set_Element;
+  namespace private_bitset
+  {
+    //***************************************************************************
+    template <size_t Active_Bits, typename TElement>
+    class bitset_common : public etl::private_bitset::bitset_impl_common<TElement>
+    {
+    public:
 
-  template <typename TElement>
-  ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Clear_Element;
+      typedef typename etl::private_bitset::bitset_impl_common<TElement>::element_type element_type;
+      
+      using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
+      using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
+      using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
+
+      static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
+      static ETL_CONSTANT size_t Size               = Active_Bits;
+      static ETL_CONSTANT size_t Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
+
+#if ETL_USING_CPP11
+      static ETL_CONSTANT etl::bitset_storage_model Storage_Model = (bitset_common<Active_Bits, TElement>::Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
+#else
+      static ETL_CONSTANT etl::bitset_storage_model Storage_Model;
+#endif
+
+      typedef etl::span<element_type,       Number_Of_Elements> span_type;
+      typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
+
+    private:
+
+      static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - ((Number_Of_Elements * Bits_Per_Element) - Active_Bits)) % Bits_Per_Element);
+
+    public:
+
+      static ETL_CONSTANT TElement Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+    };
+
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Number_Of_Elements;
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Size;
+
+#if ETL_USING_CPP11
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT etl::bitset_storage_model bitset_common<Active_Bits, TElement>::Storage_Model;
+#else
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT etl::bitset_storage_model bitset_common<Active_Bits, TElement>::Storage_Model = (bitset_common<Active_Bits, TElement>::Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
+#endif
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Top_Mask_Shift;
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT TElement bitset_common<Active_Bits, TElement>::Top_Mask;  
+  }
 
   //***************************************************************************
-  template <size_t Active_Bits = 0U,
-            typename TElement = char,
-            bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
+  /// Bitset forward declaration
+  //***************************************************************************
+  template <size_t   Active_Bits = 0U,
+            typename TElement    = unsigned char>
   class bitset;
 
   //***************************************************************************
   /// Specialisation for zero bits.
-  /// Just defines 'npos'.
   //***************************************************************************
   template <>
-  class bitset<0U, char, true> : public bitset_constants<>
-  {
-  };
-
-  //***************************************************************************
-  /// Specialisation for zero bits.
-  //***************************************************************************
-  template <>
-  class bitset<0U, char, false> : public bitset_constants<>
-  {
-  };
-
-  //***************************************************************************
-  /// Specialisation that uses a single element if the element type is the 
-  /// same size as the number of active bits.
-  //***************************************************************************
-  template <size_t   Active_Bits, typename TElement>
-  class bitset<Active_Bits, TElement, true> : public bitset_constants<>
+  class bitset<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char>
   {
   public:
 
-    // The element type is the unsigned variant of 'TElement'.
-    typedef typename etl::make_unsigned<TElement>::type element_type;
-
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
-
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT size_t       Number_Of_Elements = 1U;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Bits_Per_Element;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<typename etl::make_unsigned<element_type>::type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
-    static ETL_CONSTANT element_type Top_Mask           = All_Set_Element;
-
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
-
-    //*************************************************************************
-    /// The reference type returned.
-    //*************************************************************************
-    class bit_reference
-    {
-    public:
-
-      friend class bitset;
-
-      //*******************************
-      /// Copy constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
-        : p_bitset(other.p_bitset)
-        , position(other.position)
-      {
-      }
-
-      //*******************************
-      /// Conversion operator.
-      //*******************************
-      ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT
-      {
-        return p_bitset->test(position);
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, b);
-        return *this;
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, bool(r));
-        return *this;
-      }
-
-      //*******************************
-      /// Flip the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT
-      {
-        p_bitset->flip(position);
-        return *this;
-      }
-
-      //*******************************
-      /// Return the logical inverse of the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT
-      {
-        return !p_bitset->test(position);
-      }
-
-    private:
-
-      //*******************************
-      /// Default constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT
-        : p_bitset(ETL_NULLPTR)
-        , position(0)
-      {
-      }
-
-      //*******************************
-      /// Constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(bitset<Active_Bits, TElement, true>& r_bitset, size_t position_) ETL_NOEXCEPT
-        : p_bitset(&r_bitset)
-        , position(position_)
-      {
-      }
-
-      bitset<Active_Bits, TElement, true>* p_bitset; ///< The bitset.
-      size_t position; ///< The position in the bitset.
-    };
-
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-    }
-
-    //*************************************************************************
-    /// Copy constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-      : buffer(other.buffer)
-    {
-    }
-
-    //*************************************************************************
-    /// Construct from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT
-      : buffer(element_type(value))
-    {
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Assignment operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer = other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set() ETL_NOEXCEPT
-    {
-      buffer = All_Set_Element;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(element_type value) ETL_NOEXCEPT
-    {
-      buffer = value;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(size_t position, bool value = true)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      if (value == true)
-      {
-        buffer |= mask;
-      }
-      else
-      {
-        buffer &= ~mask;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const char* text) ETL_NOEXCEPT
-    {      
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const wchar_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const char16_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const char32_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const char* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STR('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a wide string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const wchar_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRL('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u16 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const char16_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRu('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u32 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const char32_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRU('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Get as an integral value.
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
-    {
-      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small");
-
-      T v = T(0);
-
-      const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element;
-
-      if (OK)
-      {
-        v = T(typename etl::make_unsigned<T>::type(buffer));
-      }
-
-      return v;
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long>();
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long long>();
-    }
-
-    //*************************************************************************
-    /// Reset all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& reset() ETL_NOEXCEPT
-    {
-      buffer = All_Clear_Element;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Reset the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& reset(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      buffer &= ~mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Tests a bit at a position.
-    /// Positions greater than the number of configured bits will return <b>false</b>.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool test(size_t position) const
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
-
-      const element_type mask = element_type(element_type(1) << position);
-      return (buffer & mask) != 0U;
-    }
-
-    //*************************************************************************
-    /// The number of bits in the bitset.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
-    {
-      return Active_Bits;
-    }
-
-    //*************************************************************************
-    /// Count the number of bits set.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
-    {
-      return etl::count_bits(buffer);
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
-    {
-      return buffer == All_Set_Element;
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
-    {
-      return buffer == (All_Set_Element & mask);
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
-    {
-      return buffer == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
-    {
-      return (buffer & mask) == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
-    {
-      return !none();
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
-    {
-      return !none(mask);
-    }
-
-    //*************************************************************************
-    /// Flip all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& flip() ETL_NOEXCEPT
-    {
-      buffer = ~buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip some of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& flip_bits(element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
-    {
-      buffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& flip(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      buffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Read [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        const element_type mask = element_type(element_type(1) << position);
-        return (buffer & mask) != 0U;
-      }
-
-      return false;
-    }
-
-    //*************************************************************************
-    /// Write [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT
-    {
-      return bit_reference(*this, position);
-    }
-
-    //*************************************************************************
-    /// Returns a string representing the bitset.
-    //*************************************************************************
-#if ETL_USING_CPP11
-    template <typename TString = etl::string<Active_Bits>>
-#else
-    template <typename TString>
-#endif
-    ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
-                                      typename TString::value_type one  = typename TString::value_type('1')) const
-    {
-      TString result;
-
-      result.resize(Active_Bits, '\0');
-
-      // Check that the string type can contain the digits.
-      ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result);
-
-      for (size_t i = Active_Bits; i > 0; --i)
-      {
-        result[Active_Bits - i] = test(i - 1) ? one : zero;
-      }
-
-      return result;
-    }
-
-    //*************************************************************************
-    /// Finds the first bit in the specified state.
-    ///\param state The state to search for.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
-    {
-      return find_next(state, 0U);
-    }
-
-    //*************************************************************************
-    /// Finds the next bit in the specified state.
-    ///\param state    The state to search for.
-    ///\param position The position to start from.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        // Where to start.
-        size_t bit = position;
-
-        element_type mask = 1U << position;
-
-        // Needs checking?
-        if ((state && (buffer != All_Clear_Element)) || (!state && (buffer != All_Set_Element)))
-        {
-          // For each bit in the element...
-          while (bit < Active_Bits)
-          {
-            // Equal to the required state?
-            if (((buffer & mask) != 0) == state)
-            {
-              return bit;
-            }
-
-            // Move on to the next bit.
-            mask <<= 1;
-            ++bit;
-          }
-        }
-      }
-
-      return npos;
-    }
-
-    //*************************************************************************
-    /// operator &
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator &(const bitset<Active_Bits, TElement, true>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp &= other;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator &=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator &=(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer &= other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator |
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator |(const bitset<Active_Bits, TElement, true>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp |= other;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator |=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator |=(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer |= other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ^
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator ^(const bitset<Active_Bits, TElement, true>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp ^= other;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator ^=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator ^=(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer ^= other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ~
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator ~() const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp.flip();
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator <<
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator <<(size_t shift) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp <<= shift;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator <<=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator <<=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        buffer <<= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator >>
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator >>(size_t shift) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement> temp(*this);
-
-      temp >>= shift;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator >>=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator >>=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        buffer >>= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ==
-    //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement, true>& lhs, const bitset<Active_Bits, TElement, true>& rhs) ETL_NOEXCEPT
-    {
-      return (lhs.buffer == rhs.buffer);
-    }
-
-    //*************************************************************************
-    /// swap
-    //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      element_type temp = buffer;
-      buffer = other.buffer;
-      other.buffer = temp;
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT
-    {
-      return span_type(&buffer, 1);
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a const span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT
-    {
-      return const_span_type(&buffer, 1);
-    }
-
-  private:
-
-    element_type buffer;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
+
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Size;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Storage_Model;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Top_Mask;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Allocated_Bits;
   };
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Bits_Per_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Number_Of_Elements;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Allocated_Bits;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Set_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Clear_Element;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Top_Mask_Shift;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::Top_Mask;
-
   //*************************************************************************
-  /// The specialisation that uses an array of the default element type.
+  /// The bitset top level template.
   //*************************************************************************
   template <size_t Active_Bits, typename TElement>
-  class bitset<Active_Bits, TElement, false> : public bitset_constants<>
+  class bitset : public etl::private_bitset::bitset_common<Active_Bits, TElement>
   {
-  private:
-
-    //*************************************************************************
-    // If the 'TElement' is the default 'void', then use 'char', otherwise uses
-    // the unsigned variant of 'TElement'.
-    //*************************************************************************
-    struct select_element_type
-    {
-      typedef typename etl::make_unsigned<typename etl::conditional<etl::is_same<void, TElement>::value, char, TElement>::type>::type type;
-    };  
-
   public:
 
-    typedef typename select_element_type::type element_type;
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
-      
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::bitset_impl<element_type>::Bits_Per_Element;
-    static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type All_Set_Element    = etl::bitset_impl<element_type>::All_Set_Element;
-    static ETL_CONSTANT element_type All_Clear_Element  = etl::bitset_impl<element_type>::All_Clear_Element;
-    static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+    ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
 
-    static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::element_type    element_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::span_type       span_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::const_span_type const_span_type;
 
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Size;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Storage_Model;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Allocated_Bits;
 
     //*************************************************************************
     /// The reference type returned.
@@ -1827,7 +2026,7 @@ namespace etl
       {
       }
 
-      bitset<Active_Bits, TElement, false>* p_bitset; ///< The bitset.
+      bitset<Active_Bits, TElement>* p_bitset; ///< The bitset.
       size_t position; ///< The position in the bitset.
     };
 
@@ -1837,74 +2036,74 @@ namespace etl
     ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT
       : buffer()
     {
-      reset();
+      implementation::reset_all(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Copy constructor.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
       : buffer()
     {
-      etl::copy_n(other.buffer, Number_Of_Elements, buffer);
+      implementation::operator_assignment(buffer, other.buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Construct from a value.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT
+    template <typename TValue>
+    ETL_CONSTEXPR14 bitset(TValue value, typename etl::enable_if<is_integral<TValue>::value>::type* = 0) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.initialise(buffer, Number_Of_Elements, value);
-      clear_unused_bits_in_msb();
+      implementation::template initialise<element_type>(buffer, Number_Of_Elements, value);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset(TPString text, typename etl::enable_if<is_same<TPString, const char*>::value>::type* = 0) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset(TPString text, typename etl::enable_if<is_same<TPString, const wchar_t*>::value>::type* = 0) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset(TPString text, typename etl::enable_if<is_same<TPString, const char16_t*>::value>::type* = 0) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset(TPString text, typename etl::enable_if<is_same<TPString, const char32_t*>::value>::type* = 0) ETL_NOEXCEPT
       : buffer()
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Assignment operator.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      etl::copy_n(other.buffer, Number_Of_Elements, buffer);
+      implementation::operator_assignment(buffer, other.buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -1912,10 +2111,9 @@ namespace etl
     //*************************************************************************
     /// Set all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      etl::fill_n(buffer, Number_Of_Elements, All_Set_Element);
-      clear_unused_bits_in_msb();
+      implementation::set_all(buffer, Number_Of_Elements, Top_Mask);
 
       return *this;
     }
@@ -1923,22 +2121,38 @@ namespace etl
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(size_t position, bool value = true)
+    ETL_CONSTEXPR14
+    bitset<Active_Bits, TElement>& set(size_t position, bool value = true)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      ibitset.set(buffer, Number_Of_Elements, position, value);
-      clear_unused_bits_in_msb();
+      implementation::set_position(buffer, position, value);
       
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const char* text) ETL_NOEXCEPT
+    template <size_t Position>
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(bool value = true)
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position>(buffer, value);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set()
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position, Value>(buffer);
 
       return *this;
     }
@@ -1946,39 +2160,12 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const wchar_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const char16_t* text) ETL_NOEXCEPT
-    {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const char32_t* text) ETL_NOEXCEPT
-    {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const char* text) ETL_NOEXCEPT
-    {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -1986,9 +2173,58 @@ namespace etl
     //*************************************************************************
     /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const wchar_t*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a char16 string.
+    //*************************************************************************
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char16_t*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
+    {
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a char32 string.
+    //*************************************************************************
+    template <typename TPString>
+    ETL_CONSTEXPR14 
+    typename etl::enable_if<etl::is_same<TPString, const char32_t*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
+    {
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a string.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const char* text) ETL_NOEXCEPT
+    {
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a wide string.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    {
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -1996,9 +2232,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const char16_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2006,9 +2242,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const char32_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -2018,36 +2254,76 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
       value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
+      ETL_STATIC_ASSERT(etl::integral_limits<T>::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
 
-      return ibitset.template value<T>(buffer, Number_Of_Elements);
+      return implementation::template value<T>(buffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    /// Run time position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+    T extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
+
+      ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
+
+      return implementation::template extract<T>(buffer, position, length);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    /// Compile time position and length.
+    //*************************************************************************
+#if ETL_USING_CPP11    
+		template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#else
+	  template <typename T, size_t Position, size_t Length>
+#endif
+    ETL_CONSTEXPR14
+    T extract() const
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value,              "Only integral types are supported");
+      ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
+
+      return implementation::template extract<T, Position, Length>(buffer);
     }
 
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
+    unsigned long to_ulong() const
     {
-      return value<unsigned long>();
+      ETL_ASSERT(etl::integral_limits<unsigned long>::bits >= Active_Bits, ETL_ERROR(etl::bitset_overflow));
+
+      return implementation::template value<unsigned long>(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Get as an unsigned long long.
     //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
+    unsigned long long to_ullong() const
     {
-      return value<unsigned long long>();
+      ETL_ASSERT(etl::integral_limits<unsigned long long>::bits >= Active_Bits, ETL_ERROR(etl::bitset_overflow));
+
+      return implementation::template value<unsigned long long>(buffer, Number_Of_Elements);
     }
+
     //*************************************************************************
     /// Reset all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& reset() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& reset() ETL_NOEXCEPT
     {
-      etl::fill_n(buffer, Number_Of_Elements, All_Clear_Element);
+      implementation::reset_all(buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2055,11 +2331,11 @@ namespace etl
     //*************************************************************************
     /// Reset the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& reset(size_t position)
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& reset(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      ibitset.reset(buffer, Number_Of_Elements, position);
+      implementation::reset_position(buffer, position);
 
       return *this;
     }
@@ -2072,23 +2348,93 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
 
-      return ibitset.test(buffer, Number_Of_Elements, position);
+      return implementation::test(buffer, position);
     }
  
+    //*************************************************************************
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will not compile.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14 bool test() const
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      return implementation::test(buffer, Position);
+    }
+
     //*************************************************************************
     /// The number of bits in the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
+    static ETL_CONSTEXPR size_t size() ETL_NOEXCEPT
     {
       return Active_Bits;
     }
 
+    //*************************************************************************
+    /// The number of storage elements in the bitset.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t number_of_elements() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements;
+    }
+
+    //*************************************************************************
+    /// The value of a set element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_set_element() ETL_NOEXCEPT
+    {
+      return All_Set_Element;
+    }
+
+    //*************************************************************************
+    /// The value of a clear element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_clear_element() ETL_NOEXCEPT
+    {
+      return All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// The number of bits in an element.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t bits_per_element() ETL_NOEXCEPT
+    {
+      return Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The mask for the msb element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type top_mask() ETL_NOEXCEPT
+    {
+      return Top_Mask;
+    }
+
+    //*************************************************************************
+    /// The total number of bits of storage, including unused.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t allocated_bits() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements * Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The storage model for the bitset.
+    /// etl::bitset_storage_model::Single
+    /// etl::bitset_storage_model::Multi
+    //*************************************************************************
+    static ETL_CONSTEXPR etl::bitset_storage_model storage_model() ETL_NOEXCEPT
+    {
+      return Storage_Model;
+    }
+
     //*************************************************************************
     /// Count the number of bits set.
     //*************************************************************************
     ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
     {
-      return ibitset.count(buffer, Number_Of_Elements);
+      return implementation::count(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2096,7 +2442,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
     {
-      return ibitset.all(buffer, Number_Of_Elements, Top_Mask);
+      return implementation::all(buffer, Number_Of_Elements, Top_Mask);
+    }
+
+    //*************************************************************************
+    // Are all the mask bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::all(buffer, Number_Of_Elements, Top_Mask, mask);
     }
 
     //*************************************************************************
@@ -2104,7 +2460,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
     {
-      return ibitset.none(buffer, Number_Of_Elements);
+      return implementation::none(buffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Are none of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::none(buffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
@@ -2112,16 +2478,25 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
     {
-      return !none();
+      return implementation::any(buffer, Number_Of_Elements);
     }
  
+    //*************************************************************************
+    /// Are any of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::any(buffer, Number_Of_Elements, mask);
+    }
+
     //*************************************************************************
     /// Flip all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& flip() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& flip() ETL_NOEXCEPT
     {
-      ibitset.flip(buffer, Number_Of_Elements);
-      clear_unused_bits_in_msb();
+      implementation::flip_all(buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2129,11 +2504,11 @@ namespace etl
     //*************************************************************************
     /// Flip the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& flip(size_t position)
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& flip(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      ibitset.flip(buffer, Number_Of_Elements, position);
+      implementation::flip_position(buffer, position);
 
       return *this;
     }
@@ -2143,7 +2518,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.test(buffer, Number_Of_Elements, position);
+      return implementation::test(buffer, position);
     }
 
     //*************************************************************************
@@ -2165,7 +2540,7 @@ namespace etl
     ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
                                       typename TString::value_type one  = typename TString::value_type('1')) const
     {
-      return ibitset.template to_string<TString>(buffer, Number_Of_Elements, Active_Bits, zero, one);
+      return implementation::template to_string<TString>(buffer, Active_Bits, zero, one);
     }
 
     //*************************************************************************
@@ -2175,7 +2550,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, 0);
+      return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, 0);
     }
 
     //*************************************************************************
@@ -2186,17 +2561,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, position);
+      return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, position);
     }
 
     //*************************************************************************
     /// operator &
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator &(const bitset<Active_Bits, TElement, false>& other) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator &(const bitset<Active_Bits, TElement>& other) const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp &= other;
+      implementation::operator_and(temp.buffer, other.buffer, Number_Of_Elements);
 
       return temp;
     }
@@ -2204,9 +2579,9 @@ namespace etl
     //*************************************************************************
     /// operator &=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator &=(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator &=(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.and_equals(&buffer[0], &other.buffer[0], Number_Of_Elements);
+      implementation::operator_and(buffer, other.buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2214,11 +2589,11 @@ namespace etl
     //*************************************************************************
     /// operator |
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator |(const bitset<Active_Bits, TElement, false>& other) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator |(const bitset<Active_Bits, TElement>& other) const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp |= other;
+      implementation::operator_or(temp.buffer, other.buffer, Number_Of_Elements);
 
       return temp;
     }
@@ -2226,9 +2601,9 @@ namespace etl
     //*************************************************************************
     /// operator |=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator |=(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator |=(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.or_equals(&buffer[0], &other.buffer[0], Number_Of_Elements);
+      implementation::operator_or(&buffer[0], &other.buffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -2236,11 +2611,11 @@ namespace etl
     //*************************************************************************
     /// operator ^
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator ^(const bitset<Active_Bits, TElement, false>& other) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator ^(const bitset<Active_Bits, TElement>& other) const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp ^= other;
+      implementation::operator_xor(temp.buffer, other.buffer, Number_Of_Elements);
 
       return temp;
     }
@@ -2248,9 +2623,9 @@ namespace etl
     //*************************************************************************
     /// operator ^=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator ^=(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator ^=(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.xor_equals(&buffer[0], &other.buffer[0], Number_Of_Elements);
+      implementation::operator_xor(buffer, other.buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -2258,11 +2633,11 @@ namespace etl
     //*************************************************************************
     /// operator ~
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator ~() const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator ~() const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp.flip();
+      implementation::flip_all(temp.buffer, Number_Of_Elements);
 
       return temp;
     }
@@ -2270,11 +2645,11 @@ namespace etl
     //*************************************************************************
     /// operator <<
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator <<(size_t shift) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator <<(size_t shift) const ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-      temp <<= shift;
+      implementation::operator_shift_left(temp.buffer, Number_Of_Elements, Active_Bits, shift);
 
       return temp;
     }
@@ -2282,16 +2657,15 @@ namespace etl
     //*************************************************************************
     /// operator <<=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator <<=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator <<=(size_t shift) ETL_NOEXCEPT
     {
       if (shift >= Active_Bits)
       {
-        reset();
+        implementation::reset_all(buffer, Number_Of_Elements);
       }
       else
       {
-        ibitset.shift_left_equals(buffer, Number_Of_Elements, shift);
-        clear_unused_bits_in_msb();
+        implementation::operator_shift_left(buffer, Number_Of_Elements, Active_Bits, shift);
       }
       
       return *this;
@@ -2300,11 +2674,11 @@ namespace etl
     //*************************************************************************
     /// operator >>
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator >>(size_t shift) const ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator >>(size_t shift) const ETL_NOEXCEPT
     {
-      bitset<Active_Bits, TElement, false> temp(*this);
+      bitset<Active_Bits, TElement> temp(*this);
 
-      temp >>= shift;
+      implementation::operator_shift_right(temp.buffer, Number_Of_Elements, Active_Bits, shift);
 
       return temp;
     }
@@ -2312,15 +2686,15 @@ namespace etl
     //*************************************************************************
     /// operator >>=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator >>=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator >>=(size_t shift) ETL_NOEXCEPT
     {
       if (shift >= Active_Bits)
       {
-        reset();
+        implementation::reset_all(buffer, Number_Of_Elements);
       }
       else
       {
-        ibitset.shift_right_equals(buffer, Number_Of_Elements, shift);
+        implementation::operator_shift_right(buffer, Number_Of_Elements, Active_Bits, shift);
       }
 
       return *this;
@@ -2329,19 +2703,25 @@ namespace etl
     //*************************************************************************
     /// operator ==
     //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement, false>& lhs, const bitset<Active_Bits, TElement, false>& rhs) ETL_NOEXCEPT
+    friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
     {
-      return etl::equal(lhs.buffer, 
-                        lhs.buffer + lhs.Number_Of_Elements,
-                        rhs.buffer);
+      return implementation::operator_equality(lhs.buffer, rhs.buffer, lhs.Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// operator !=
+    //*************************************************************************
+    friend ETL_CONSTEXPR14 bool operator !=(const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+    {
+      return !(lhs == rhs);
     }
 
     //*************************************************************************
     /// swap
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.swap(buffer, other.buffer, Number_Of_Elements);
+      implementation::swap(buffer, other.buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -2367,43 +2747,24 @@ namespace etl
     //*************************************************************************
     /// Correct the unused top bits after bit manipulation.
     //*************************************************************************
-    ETL_CONSTEXPR14 void clear_unused_bits_in_msb() ETL_NOEXCEPT
-    {
-      buffer[Number_Of_Elements - 1U] &= Top_Mask;
-    }
+    //ETL_CONSTEXPR14 static void clear_unused_bits_in_msb(pointer pbuffer) ETL_NOEXCEPT
+    //{
+    //  pbuffer[Number_Of_Elements - 1U] &= Top_Mask;
+    //}
 
-    etl::bitset_impl<element_type> ibitset;
+    // The implementation of the bitset functionality.
+    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi> implementation;
 
-    element_type buffer[Number_Of_Elements > 0U ? Number_Of_Elements : 1U];
+    // The storage for the bitset.
+    element_type buffer[Number_Of_Elements];
   };
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Bits_Per_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Number_Of_Elements;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Allocated_Bits;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Set_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Clear_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Top_Mask_Shift;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::Top_Mask;
-
   //***************************************************************************
   /// operator &
   ///\ingroup bitset
   //***************************************************************************
-  template <size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bitset<Active_Bits> operator & (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+  template <size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bitset<Active_Bits> operator & (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
   {
     bitset<Active_Bits> temp(lhs);
     temp &= rhs;
@@ -2414,8 +2775,8 @@ namespace etl
   /// operator |
   ///\ingroup bitset
   //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bitset<Active_Bits> operator | (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+  template<size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bitset<Active_Bits> operator | (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
   {
     bitset<Active_Bits> temp(lhs);
     temp |= rhs;
@@ -2426,30 +2787,30 @@ namespace etl
   /// operator ^
   ///\ingroup bitset
   //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bitset<Active_Bits> operator ^ (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+  template<size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bitset<Active_Bits> operator ^ (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
   {
     bitset<Active_Bits> temp(lhs);
     temp ^= rhs;
     return temp;
   }
+}
 
-  //***************************************************************************
-  /// operator !=
-  ///\ingroup bitset
-  //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bool operator != (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
-  {
-    return !(lhs == rhs);
-  }
+//***************************************************************************
+/// operator !=
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 bool operator != (const etl::bitset<Active_Bits, TElement>& lhs, const etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
 }
 
 //*************************************************************************
 /// swap
 //*************************************************************************
-template <size_t Active_Bits, typename TElement, bool IsSingleElement>
-ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement, IsSingleElement>& lhs, etl::bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+template <size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement>& lhs, etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
 {
   lhs.swap(rhs);
 }
@@ -2461,932 +2822,55 @@ namespace etl
 {
   //***************************************************************************
   template <size_t Active_Bits = 0U,
-            typename TElement = char,
-            bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
-    class bitset_ext;
-
-  //***************************************************************************
-  /// Specialisation for zero bits.
-  /// Just defines 'npos'.
-  //***************************************************************************
-  template <>
-  class bitset_ext<0U, char, true> : public bitset_constants<>
-  {
-  };
+            typename TElement = unsigned char>
+  class bitset_ext;
 
   //***************************************************************************
   /// Specialisation for zero bits.
   //***************************************************************************
   template <>
-  class bitset_ext<0U, char, false> : public bitset_constants<>
-  {
-  };
-
-  //***************************************************************************
-  /// Specialisation that uses a single element if the element type is the 
-  /// same size as the number of active bits.
-  //***************************************************************************
-  template <size_t   Active_Bits, typename TElement>
-  class bitset_ext<Active_Bits, TElement, true> : public bitset_constants<>
+  class bitset_ext<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char>
   {
   public:
 
-    // The element type is the unsigned variant of 'TElement'.
-    typedef typename etl::make_unsigned<TElement>::type element_type;
-
-    typedef element_type* pointer;
-    typedef const element_type* const_pointer;
-
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT size_t       Number_Of_Elements = 1U;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Bits_Per_Element;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<typename etl::make_unsigned<element_type>::type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
-    static ETL_CONSTANT element_type Top_Mask           = All_Set_Element;
-
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
-
-    typedef element_type buffer_type;
-
-    //*************************************************************************
-    /// The reference type returned.
-    //*************************************************************************
-    class bit_reference
-    {
-    public:
-
-      friend class bitset_ext;
-
-      //*******************************
-      /// Copy constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
-        : p_bitset(other.p_bitset)
-        , position(other.position)
-      {
-      }
-
-      //*******************************
-      /// Conversion operator.
-      //*******************************
-      ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT
-      {
-        return p_bitset->test(position);
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, b);
-        return *this;
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, bool(r));
-        return *this;
-      }
-
-      //*******************************
-      /// Flip the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT
-      {
-        p_bitset->flip(position);
-        return *this;
-      }
-
-      //*******************************
-      /// Return the logical inverse of the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT
-      {
-        return !p_bitset->test(position);
-      }
-
-    private:
-
-      //*******************************
-      /// Default constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT
-        : p_bitset(ETL_NULLPTR)
-        , position(0)
-      {
-      }
-
-      //*******************************
-      /// Constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(bitset_ext<Active_Bits, TElement, true>& r_bitset, size_t position_) ETL_NOEXCEPT
-        : p_bitset(&r_bitset)
-        , position(position_)
-      {
-      }
-
-      bitset_ext<Active_Bits, TElement, true>* p_bitset; ///< The bitset.
-      size_t position; ///< The position in the bitset.
-    };
-
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
-    {
-      *pbuffer = All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Construct copy.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
-    {
-      *pbuffer = *other.pbuffer;
-    }
-
-    //*************************************************************************
-    /// Construct copy.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = *other.pbuffer;
-    }
-
-    //*************************************************************************
-    /// Copy Constructor (Deleted).
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT ETL_DELETE;
-
-    //*************************************************************************
-    /// Construct from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
-    {
-      *pbuffer = element_type(value);
-    }
-
-    //*************************************************************************
-    /// Construct from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = element_type(value);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
-    {
-      *pbuffer = All_Clear_Element;
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Assignment operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      *pbuffer = *other.pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set() ETL_NOEXCEPT
-    {
-      *pbuffer = All_Set_Element;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(size_t position, bool value = true)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      if (value == true)
-      {
-        *pbuffer |= mask;
-      }
-      else
-      {
-        *pbuffer &= ~mask;
-      }
-      
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const char* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const wchar_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const char16_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const char32_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const char* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STR('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a wide string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const wchar_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRL('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u16 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const char16_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRu('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u32 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const char32_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRU('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Get as an integral value.
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
-    {
-      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small");
-
-      T v = T(0);
-
-      const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element;
-
-      if (OK)
-      {
-        v = T(typename etl::make_unsigned<T>::type(*pbuffer));
-      }
-
-      return v;
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long>();
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long long>();
-    }
-
-    //*************************************************************************
-    /// Reset all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& reset() ETL_NOEXCEPT
-    {
-      *pbuffer = All_Clear_Element;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Reset the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& reset(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      *pbuffer &= ~mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Tests a bit at a position.
-    /// Positions greater than the number of configured bits will return <b>false</b>.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool test(size_t position) const
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
-
-      const element_type mask = element_type(element_type(1) << position);
-      return (*pbuffer & mask) != 0U;
-    }
-
-    //*************************************************************************
-    /// The number of bits in the bitset.
-    //*************************************************************************
-    ETL_CONSTEXPR14  size_t size() const ETL_NOEXCEPT
-    {
-      return Active_Bits;
-    }
-
-    //*************************************************************************
-    /// Count the number of bits set.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
-    {
-      return etl::count_bits(*pbuffer);
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
-    {
-      return *pbuffer == All_Set_Element;
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
-    {
-      return *pbuffer == (All_Set_Element & mask);
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
-    {
-      return *pbuffer == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
-    {
-      return (*pbuffer & mask) == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
-    {
-      return !none();
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
-    {
-      return !none(mask);
-    }
-
-    //*************************************************************************
-    /// Flip all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& flip() ETL_NOEXCEPT
-    {
-      *pbuffer = ~*pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip some of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& flip_bits(element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
-    {
-      *pbuffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& flip(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-
-      const element_type mask = element_type(element_type(1) << position);
-      *pbuffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Read [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        const element_type mask = element_type(element_type(1) << position);
-        return (*pbuffer & mask) != 0U;
-      }
-
-      return false;
-    }
-
-    //*************************************************************************
-    /// Write [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT
-    {
-      return bit_reference(*this, position);
-    }
-
-    //*************************************************************************
-    /// Returns a string representing the bitset.
-    //*************************************************************************
-#if ETL_USING_CPP11
-    template <typename TString = etl::string<Active_Bits>>
-#else
-    template <typename TString>
-#endif
-    ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
-                                      typename TString::value_type one  = typename TString::value_type('1')) const
-    {
-      TString result;
-
-      result.resize(Active_Bits, '\0');
-
-      // Check that the string type can contain the digits.
-      ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result);
-
-      for (size_t i = Active_Bits; i > 0; --i)
-      {
-        result[Active_Bits - i] = test(i - 1) ? one : zero;
-      }
-
-      return result;
-    }
-
-    //*************************************************************************
-    /// Finds the first bit in the specified state.
-    ///\param state The state to search for.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
-    {
-      return find_next(state, 0U);
-    }
-
-    //*************************************************************************
-    /// Finds the next bit in the specified state.
-    ///\param state    The state to search for.
-    ///\param position The position to start from.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        // Where to start.
-        size_t bit = position;
-
-        element_type mask = 1U << position;
-
-        // Needs checking?
-        if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element)))
-        {
-          // For each bit in the element...
-          while (bit < Active_Bits)
-          {
-            // Equal to the required state?
-            if (((*pbuffer & mask) != 0) == state)
-            {
-              return bit;
-            }
-
-            // Move on to the next bit.
-            mask <<= 1;
-            ++bit;
-          }
-        }
-      }
-
-      return npos;
-    }
-
-    //*************************************************************************
-    /// operator &=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator &=(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      *pbuffer &= *other.pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator |=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator |=(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      *pbuffer |= *other.pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ^=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator ^=(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      *pbuffer ^= *other.pbuffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator <<=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator <<=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        *pbuffer <<= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator >>=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator >>=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        *pbuffer >>= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ==
-    //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement, true>& lhs, const bitset_ext<Active_Bits, TElement, true>& rhs) ETL_NOEXCEPT
-    {
-      return (*lhs.pbuffer == *rhs.pbuffer);
-    }
-
-    //*************************************************************************
-    /// swap
-    //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      element_type temp = *pbuffer;
-      *pbuffer = *other.pbuffer;
-      *other.pbuffer = temp;
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT
-    {
-      return span_type(pbuffer, 1);
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a const span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT
-    {
-      return const_span_type(pbuffer, 1);
-    }
-
-  private:
-
-    element_type* pbuffer;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
+
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Size;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Storage_Model;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Top_Mask;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Allocated_Bits;
   };
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Bits_Per_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Number_Of_Elements;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Allocated_Bits;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Set_Element;
-    
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Clear_Element;
-    
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Top_Mask_Shift;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::Top_Mask;
-
   //*************************************************************************
-  /// The specialisation that uses an array of the default element type.
+  /// A bitset that uses externally declared storage.
   //*************************************************************************
   template <size_t Active_Bits, typename TElement>
-  class bitset_ext<Active_Bits, TElement, false> : public bitset_constants<>
+  class bitset_ext : public etl::private_bitset::bitset_common<Active_Bits, TElement>
   {
-  private:
-
-    //*************************************************************************
-    // If the 'TElement' is the default 'void', then use 'char', otherwise uses
-    // the unsigned variant of 'TElement'.
-    //*************************************************************************
-    struct select_element_type
-    {
-      typedef typename etl::make_unsigned<typename etl::conditional<etl::is_same<void, TElement>::value, char, TElement>::type>::type type;
-    };
-
   public:
 
-    typedef typename select_element_type::type element_type;
-    typedef element_type* pointer;
-    typedef const element_type* const_pointer;
+    ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
 
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::bitset_impl<element_type>::Bits_Per_Element;
-    static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type All_Set_Element    = etl::bitset_impl<element_type>::All_Set_Element;
-    static ETL_CONSTANT element_type All_Clear_Element  = etl::bitset_impl<element_type>::All_Clear_Element;
-    static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::element_type    element_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::span_type       span_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::const_span_type const_span_type;
+    
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Size;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Storage_Model;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Allocated_Bits;
 
-    static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
-
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
-
-    typedef etl::array<element_type, Number_Of_Elements> buffer_type;
+    typedef etl::array<TElement, Number_Of_Elements> buffer_type;
 
     //*************************************************************************
     /// The reference type returned.
@@ -3469,157 +2953,164 @@ namespace etl
       {
       }
 
-      bitset_ext<Active_Bits, TElement, false>* p_bitset; ///< The bitset.
+      bitset_ext<Active_Bits, TElement>* p_bitset; ///< The bitset.
       size_t position; ///< The position in the bitset.
     };
 
     //*************************************************************************
     /// Default constructor.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(element_type* pbuffer_) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 explicit bitset_ext(element_type* pbuffer_)
       : pbuffer(pbuffer_)
     {
-      reset();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::reset_all(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Default constructor.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(buffer_type& buffer) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 explicit bitset_ext(buffer_type& buffer)
       : pbuffer(buffer.data())
     {
-      reset();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::reset_all(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Construct copy.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other, element_type* pbuffer_) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other, element_type* pbuffer_)
       : pbuffer(pbuffer_)
     {
-      etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Construct copy.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other, buffer_type& buffer) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
+      implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Copy Constructor (Deleted).
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT ETL_DELETE;
+    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT ETL_DELETE;
 
     //*************************************************************************
     /// Construct from a value.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_)
       : pbuffer(pbuffer_)
     {
-      ibitset.initialise(pbuffer, Number_Of_Elements, value);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::template initialise<element_type>(pbuffer, Number_Of_Elements, value);
     }
 
     //*************************************************************************
     /// Construct from a value.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT
+    template <typename TValue>
+    ETL_CONSTEXPR14 bitset_ext(TValue value, buffer_type& buffer, typename etl::enable_if<is_integral<TValue>::value>::type* = 0) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.initialise(pbuffer, Number_Of_Elements, value);
-      clear_unused_bits_in_msb();
+      implementation::template initialise<element_type>(pbuffer, Number_Of_Elements, value);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, element_type* pbuffer_, typename etl::enable_if<is_same<TPString, const char*>::value>::type* = 0)
       : pbuffer(pbuffer_)
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, buffer_type& buffer, typename etl::enable_if<is_same<TPString, const char*>::value>::type* = 0) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, element_type* pbuffer_, typename etl::enable_if<is_same<TPString, const wchar_t*>::value>::type* = 0)
       : pbuffer(pbuffer_)
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, buffer_type& buffer, typename etl::enable_if<is_same<TPString, const wchar_t*>::value>::type* = 0) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, element_type* pbuffer_, typename etl::enable_if<is_same<TPString, const char16_t*>::value>::type* = 0)
       : pbuffer(pbuffer_)
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, buffer_type& buffer, typename etl::enable_if<is_same<TPString, const char16_t*>::value>::type* = 0) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, element_type* pbuffer_, typename etl::enable_if<is_same<TPString, const char32_t*>::value>::type* = 0)
       : pbuffer(pbuffer_)
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, buffer_type& buffer, typename etl::enable_if<is_same<TPString, const char32_t*>::value>::type* = 0) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Assignment operator.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
+      implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -3627,10 +3118,9 @@ namespace etl
     //*************************************************************************
     /// Set all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      etl::fill_n(pbuffer, Number_Of_Elements, All_Set_Element);
-      clear_unused_bits_in_msb();
+      implementation::set_all(pbuffer, Number_Of_Elements, Top_Mask);
 
       return *this;
     }
@@ -3638,12 +3128,38 @@ namespace etl
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(size_t position, bool value = true)
+    ETL_CONSTEXPR14
+      bitset_ext<Active_Bits, TElement>& set(size_t position, bool value = true)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      ibitset.set(pbuffer, Number_Of_Elements, position, value);
-      clear_unused_bits_in_msb();
+
+      implementation::set_position(pbuffer, position, value);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(bool value = true)
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position>(pbuffer, value);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set()
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position, Value>(pbuffer);
 
       return *this;
     }
@@ -3651,49 +3167,12 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const char* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const wchar_t* text) ETL_NOEXCEPT
-    {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const char16_t* text) ETL_NOEXCEPT
-    {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const char32_t* text) ETL_NOEXCEPT
-    {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const char* text) ETL_NOEXCEPT
-    {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3701,9 +3180,58 @@ namespace etl
     //*************************************************************************
     /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const wchar_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a char16 string.
+    //*************************************************************************
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char16_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
+    {
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a char32 string.
+    //*************************************************************************
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char32_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
+    {
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a string.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const char* text) ETL_NOEXCEPT
+    {
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
+    }
+
+    //*************************************************************************
+    /// Set from a wide string.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    {
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3711,9 +3239,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const char16_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3721,9 +3249,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const char32_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3733,36 +3261,75 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
+    T value() const ETL_NOEXCEPT
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
+      ETL_STATIC_ASSERT(etl::integral_limits<T>::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
 
-      return ibitset.template value<T>(pbuffer, Number_Of_Elements);
+      return implementation::template value<T>(pbuffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    /// Run time position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+      T extract(size_t position, size_t length = etl::integral_limits<T>::bits)
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
+
+      ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
+
+      return implementation::template extract<T>(pbuffer, position, length);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    /// Compile time position and length.
+    //*************************************************************************
+#if ETL_USING_CPP11
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#else
+    template <typename T, size_t Position, size_t Length>
+#endif
+    ETL_CONSTEXPR14
+    T extract() const
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value,              "Only integral types are supported");
+      ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
+
+      return implementation::template extract<T, Position, Length>(pbuffer);
     }
 
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
+    unsigned long to_ulong() const
     {
-      return value<unsigned long>();
+      ETL_ASSERT(etl::integral_limits<unsigned long>::bits >= Active_Bits, ETL_ERROR(etl::bitset_overflow));
+
+      return implementation::template value<unsigned long>(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Get as an unsigned long long.
     //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
+    unsigned long long to_ullong() const
     {
-      return value<unsigned long long>();
+      ETL_ASSERT(etl::integral_limits<unsigned long long>::bits >= Active_Bits, ETL_ERROR(etl::bitset_overflow));
+
+      return implementation::template value<unsigned long long>(pbuffer, Number_Of_Elements);
     }
+
     //*************************************************************************
     /// Reset all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& reset() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& reset() ETL_NOEXCEPT
     {
-      etl::fill_n(pbuffer, Number_Of_Elements, All_Clear_Element);
+      implementation::reset_all(pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -3770,11 +3337,11 @@ namespace etl
     //*************************************************************************
     /// Reset the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& reset(size_t position)
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& reset(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      ibitset.reset(pbuffer, Number_Of_Elements, position);
+      implementation::reset_position(pbuffer, position);
 
       return *this;
     }
@@ -3787,23 +3354,93 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
       
-      return ibitset.test(pbuffer, Number_Of_Elements, position);
+      return implementation::test(pbuffer, position);
+    }
+
+    //*************************************************************************
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will not compile.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14 bool test() const
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      return implementation::test(pbuffer, Position);
     }
 
     //*************************************************************************
     /// The number of bits in the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14  size_t size() const ETL_NOEXCEPT
+    static ETL_CONSTEXPR size_t size() ETL_NOEXCEPT
     {
       return Active_Bits;
     }
 
+    //*************************************************************************
+    /// The number of storage elements in the bitset.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t number_of_elements() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements;
+    }
+
+    //*************************************************************************
+    /// The value of a set element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_set_element() ETL_NOEXCEPT
+    {
+      return All_Set_Element;
+    }
+
+    //*************************************************************************
+    /// The value of a clear element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_clear_element() ETL_NOEXCEPT
+    {
+      return All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// The mask for the msb element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type top_mask() ETL_NOEXCEPT
+    {
+      return Top_Mask;
+    }
+
+    //*************************************************************************
+    /// The number of bits in an element.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t bits_per_element() ETL_NOEXCEPT
+    {
+      return Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The total number of bits of storage, including unused.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t allocated_bits() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements * Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The storage model for the bitset.
+    /// etl::bitset_storage_model::Single
+    /// etl::bitset_storage_model::Multi
+    //*************************************************************************
+    static ETL_CONSTEXPR etl::bitset_storage_model storage_model() ETL_NOEXCEPT
+    {
+      return Storage_Model;
+    }
+
     //*************************************************************************
     /// Count the number of bits set.
     //*************************************************************************
     ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
     {
-      return ibitset.count(pbuffer, Number_Of_Elements);
+      return implementation::count(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -3811,7 +3448,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
     {
-      return ibitset.all(pbuffer, Number_Of_Elements, Top_Mask);
+      return implementation::all(pbuffer, Number_Of_Elements, Top_Mask);
+    }
+
+    //*************************************************************************
+    // Are all the mask bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::all(pbuffer, Number_Of_Elements, Top_Mask, mask);
     }
 
     //*************************************************************************
@@ -3819,7 +3466,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
     {
-      return ibitset.none(pbuffer, Number_Of_Elements);
+      return implementation::none(pbuffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Are none of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::none(pbuffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
@@ -3827,16 +3484,25 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
     {
-      return !none();
+      return implementation::any(pbuffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Are any of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::any(pbuffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
     /// Flip all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& flip() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& flip() ETL_NOEXCEPT
     {
-      ibitset.flip(pbuffer, Number_Of_Elements);
-      clear_unused_bits_in_msb();
+      implementation::flip_all(pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -3844,11 +3510,11 @@ namespace etl
     //*************************************************************************
     /// Flip the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& flip(size_t position)
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& flip(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
       
-      ibitset.flip(pbuffer, Number_Of_Elements, position);
+      implementation::flip_position(pbuffer, position);
 
       return *this;
     }
@@ -3858,7 +3524,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.test(pbuffer, Number_Of_Elements, position);
+      return implementation::test(pbuffer, position);
     }
 
     //*************************************************************************
@@ -3878,9 +3544,9 @@ namespace etl
     template <typename TString>
 #endif
     ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
-      typename TString::value_type one = typename TString::value_type('1')) const
+                                      typename TString::value_type one  = typename TString::value_type('1')) const
     {
-      return ibitset.template to_string<TString>(pbuffer, Number_Of_Elements, Active_Bits, zero, one);
+      return implementation::template to_string<TString>(pbuffer, Active_Bits, zero, one);
     }
 
     //*************************************************************************
@@ -3890,7 +3556,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0);
+      return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0);
     }
 
     //*************************************************************************
@@ -3901,15 +3567,15 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position);
+      return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position);
     }
 
     //*************************************************************************
     /// operator &=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator &=(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator &=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.and_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::operator_and(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -3917,9 +3583,9 @@ namespace etl
     //*************************************************************************
     /// operator |=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator |=(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator |=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.or_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::operator_or(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -3927,9 +3593,9 @@ namespace etl
     //*************************************************************************
     /// operator ^=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator ^=(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator ^=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.xor_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::operator_xor(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -3937,17 +3603,9 @@ namespace etl
     //*************************************************************************
     /// operator <<=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator <<=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator <<=(size_t shift) ETL_NOEXCEPT
     {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        ibitset.shift_left_equals(pbuffer, Number_Of_Elements, shift);
-        clear_unused_bits_in_msb();
-      }
+      implementation::operator_shift_left(pbuffer, Number_Of_Elements, Active_Bits, shift);
 
       return *this;
     }
@@ -3955,16 +3613,9 @@ namespace etl
     //*************************************************************************
     /// operator >>=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator >>=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator >>=(size_t shift) ETL_NOEXCEPT
     {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        ibitset.shift_right_equals(pbuffer, Number_Of_Elements, shift);
-      }
+      implementation::operator_shift_right(pbuffer, Number_Of_Elements, Active_Bits, shift);
 
       return *this;
     }
@@ -3972,19 +3623,25 @@ namespace etl
     //*************************************************************************
     /// operator ==
     //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement, false>& lhs, const bitset_ext<Active_Bits, TElement, false>& rhs) ETL_NOEXCEPT
+    friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement>& lhs, const bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
     {
-      return etl::equal(lhs.pbuffer,
-        lhs.pbuffer + lhs.Number_Of_Elements,
-        rhs.pbuffer);
+      return implementation::operator_equality(lhs.pbuffer, rhs.pbuffer, lhs.Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// operator !=
+    //*************************************************************************
+    friend ETL_CONSTEXPR14 bool operator !=(const bitset_ext<Active_Bits, TElement>& lhs, const bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+    {
+      return !(lhs == rhs);
     }
 
     //*************************************************************************
     /// swap
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.swap(pbuffer, other.pbuffer, Number_Of_Elements);
+      implementation::swap(pbuffer, other.pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -4007,59 +3664,301 @@ namespace etl
 
   private:
 
-    //*************************************************************************
-    /// Correct the unused top bits after bit manipulation.
-    //*************************************************************************
-    ETL_CONSTEXPR14 void clear_unused_bits_in_msb() ETL_NOEXCEPT
-    {
-      pbuffer[Number_Of_Elements - 1U] &= Top_Mask;
-    }
+    // The implementation of the bitset functionality.
+    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi> implementation;
 
-    etl::bitset_impl<element_type> ibitset;
+    // Pointer to the storage for the bitset.
     element_type* pbuffer;
   };
+}
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Bits_Per_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Number_Of_Elements;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Allocated_Bits;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Set_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Clear_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Top_Mask_Shift;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::Top_Mask;
-
-  //***************************************************************************
-  /// operator !=
-  ///\ingroup bitset
-  //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bool operator != (const bitset_ext<Active_Bits, TElement, IsSingleElement>& lhs, const bitset_ext<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
-  {
-    return !(lhs == rhs);
-  }
+//***************************************************************************
+/// operator !=
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 bool operator != (const etl::bitset_ext<Active_Bits, TElement>& lhs, const etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
 }
 
 //*************************************************************************
 /// swap
 //*************************************************************************
-template <size_t Active_Bits, typename TElement, bool IsSingleElement>
-ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement, IsSingleElement>& lhs, etl::bitset_ext<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+template <size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement>& lhs, etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
 {
   lhs.swap(rhs);
 }
 
+namespace etl
+{
+  namespace private_bitset
+  {
+    //*************************************************************************
+    /// Compare bitset spans.
+    /// Assumes that the lhs span's element type is larger than rhs's.
+    //*************************************************************************
+    template <typename TLhsSpan, typename TRhsSpan>
+    bool compare_bitset_spans(const TLhsSpan& lhs_span, const TRhsSpan& rhs_span)
+    {
+      typedef typename TLhsSpan::value_type lhs_element_t;
+      typedef typename TRhsSpan::value_type rhs_element_t;
+
+      const int steps = static_cast<int>(sizeof(lhs_element_t) / sizeof(rhs_element_t));
+
+      typename TLhsSpan::iterator lhs_itr = lhs_span.begin();
+      typename TRhsSpan::iterator rhs_itr = rhs_span.begin();
+
+      while (lhs_itr != lhs_span.end())
+      {
+        const lhs_element_t& lhs_value = *lhs_itr;
+
+        // Build the rhs element in terms of the lhs element type.
+        lhs_element_t rhs_value = 0;
+
+        const int shift_step = etl::integral_limits<rhs_element_t>::bits;
+        int shift = 0;
+
+        for (int i = 0; i < steps; ++i)
+        {
+          rhs_value |= (static_cast<lhs_element_t>(*rhs_itr) << shift);
+          ++rhs_itr;
+          shift += shift_step;
+        }
+
+        if (lhs_value != rhs_value)
+        {
+          return false;
+        }
+
+        ++lhs_itr;
+      }
+
+      return true;
+    }
+  }
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset 
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator == (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset<Active_Bits, TLhsElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset<Active_Bits, TRhsElement>::const_span_type rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset 
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset_ext
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator == (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset_ext<Active_Bits, TLhsElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset_ext<Active_Bits, TRhsElement>::const_span_type rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset_ext
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset compared with bitset_ext, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator == (const etl::bitset<Active_Bits, TElement>& lhs, const etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  const char   Storage_Model      = etl::bitset<Active_Bits, TElement>::Storage_Model;
+  const size_t Number_Of_Elements = etl::bitset<Active_Bits, TElement>::Number_Of_Elements;
+
+  typename etl::bitset<Active_Bits, TElement>::const_span_type     lhs_span = lhs.span();
+  typename etl::bitset_ext<Active_Bits, TElement>::const_span_type rhs_span = rhs.span();
+
+  typedef etl::bitset_impl<TElement, Storage_Model> implementation;
+
+  return implementation::operator_equality(lhs_span.begin(), rhs_span.begin(), Number_Of_Elements);
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset compared with bitset_ext, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator != (const etl::bitset<Active_Bits, TElement>& lhs, const etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset_ext compared with bitset, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator == (const etl::bitset_ext<Active_Bits, TElement>& lhs, const etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  const char   Storage_Model      = etl::bitset<Active_Bits, TElement>::Storage_Model;
+  const size_t Number_Of_Elements = etl::bitset<Active_Bits, TElement>::Number_Of_Elements;
+
+  typename etl::bitset_ext<Active_Bits, TElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset<Active_Bits, TElement>::const_span_type     rhs_span = rhs.span();
+
+  typedef etl::bitset_impl<TElement, Storage_Model> implementation;
+
+  return implementation::operator_equality(lhs_span.begin(), rhs_span.begin(), Number_Of_Elements);
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset_ext compared with bitset, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator != (const etl::bitset_ext<Active_Bits, TElement>& lhs, const etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset compared with bitset_ext, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+operator == (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset<Active_Bits, TLhsElement>::const_span_type     lhs_span = lhs.span();
+  typename etl::bitset_ext<Active_Bits, TRhsElement>::const_span_type rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset compared with bitset_ext, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset_ext compared with bitset, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator == (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset_ext<Active_Bits, TLhsElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset<Active_Bits, TRhsElement>::const_span_type     rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset_ext compared with bitset, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
 
 #include "minmax_pop.h"
 
diff --git a/include/etl/private/crc_parameters.h b/include/etl/private/crc_parameters.h
index 72cd1ef5..705684c0 100644
--- a/include/etl/private/crc_parameters.h
+++ b/include/etl/private/crc_parameters.h
@@ -79,6 +79,8 @@ namespace etl
     typedef crc_parameters<uint8_t, 0x07U, 0x00U, 0x55U, false> crc8_itu_parameters;
     typedef crc_parameters<uint8_t, 0x31U, 0x00U, 0x00U, true>  crc8_maxim_parameters;
     typedef crc_parameters<uint8_t, 0x9BU, 0x00U, 0x00U, true>  crc8_wcdma_parameters;
+    typedef crc_parameters<uint8_t, 0x1DU, 0xFFU, 0xFFU, false> crc8_j1850_parameters;
+    typedef crc_parameters<uint8_t, 0x1DU, 0x00U, 0x00U, false> crc8_j1850_zero_parameters;
 
     // 16 bit.
     typedef crc_parameters<uint16_t, 0x8005U, 0x0000U, 0x0000U, true>  crc16_parameters;
diff --git a/include/etl/private/diagnostic_null_dereference_push.h b/include/etl/private/diagnostic_null_dereference_push.h
new file mode 100644
index 00000000..3f48168c
--- /dev/null
+++ b/include/etl/private/diagnostic_null_dereference_push.h
@@ -0,0 +1,44 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2024 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+/*
+ * The header include guard has been intentionally omitted.
+ * This file is intended to evaluated multiple times by design.
+ */
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__llvm__)
+  #pragma GCC diagnostic push 
+  #pragma GCC diagnostic ignored "-Wnull-dereference"
+#endif
+
+#if defined(__clang__) || defined(__llvm__)
+  #pragma clang diagnostic push 
+  #pragma clang diagnostic ignored "-Wnull-dereference"
+#endif
diff --git a/include/etl/private/ivectorpointer.h b/include/etl/private/ivectorpointer.h
index 52b9924c..52f938fe 100644
--- a/include/etl/private/ivectorpointer.h
+++ b/include/etl/private/ivectorpointer.h
@@ -986,7 +986,7 @@ namespace etl
   /// Less than or equal operator.
   ///\param lhs Reference to the first vector.
   ///\param rhs Reference to the second vector.
-  ///\return <b>true</b> if the first vector is lexigraphically less than or equal to the second, otherwise <b>false</b>
+  ///\return <b>true</b> if the first vector is lexicographically less than or equal to the second, otherwise <b>false</b>
   ///\ingroup vector
   //***************************************************************************
   template <typename T>
@@ -999,7 +999,7 @@ namespace etl
   /// Greater than or equal operator.
   ///\param lhs Reference to the first vector.
   ///\param rhs Reference to the second vector.
-  ///\return <b>true</b> if the first vector is lexigraphically greater than or equal to the second, otherwise <b>false</b>
+  ///\return <b>true</b> if the first vector is lexicographically greater than or equal to the second, otherwise <b>false</b>
   ///\ingroup vector
   //***************************************************************************
   template <typename T>
diff --git a/include/etl/private/variant_variadic.h b/include/etl/private/variant_variadic.h
index 28b2d99a..d1543f70 100644
--- a/include/etl/private/variant_variadic.h
+++ b/include/etl/private/variant_variadic.h
@@ -41,6 +41,7 @@ SOFTWARE.
 #include "../placement_new.h"
 #include "../visitor.h"
 #include "../memory.h"
+#include "../compare.h"
 #include "../initializer_list.h"
 
 #include <stdint.h>
@@ -531,7 +532,7 @@ namespace etl
 
       default_construct_in_place<type>(data);
       operation = operation_type<type, etl::is_copy_constructible<type>::value, etl::is_move_constructible<type>::value>::do_operation;
-      type_id   = 0U;
+      type_id   = variant_npos;
     }
 #include "diagnostic_pop.h"
 
@@ -701,6 +702,29 @@ namespace etl
       return *static_cast<T*>(data);
     }
 
+#if ETL_HAS_INITIALIZER_LIST
+    //***************************************************************************
+    /// Emplace by type with variadic constructor parameters.
+    //***************************************************************************
+    template <typename T, typename U, typename... TArgs>
+    T& emplace(std::initializer_list<U> il, TArgs&&... args)
+    {
+      static_assert(etl::is_one_of<T, TTypes...>::value, "Unsupported type");
+
+      using type = etl::remove_cvref_t<T>;
+
+      operation(private_variant::Destroy, data, nullptr);
+
+      construct_in_place_args<type>(data, il, etl::forward<TArgs>(args)...);
+
+      operation = operation_type<type, etl::is_copy_constructible<type>::value, etl::is_move_constructible<type>::value>::do_operation;
+
+      type_id = etl::private_variant::parameter_pack<TTypes...>::template index_of_type<T>::value;
+
+      return *static_cast<T*>(data);
+    }
+#endif
+
     //***************************************************************************
     /// Emplace by index with variadic constructor parameters.
     //***************************************************************************
@@ -722,6 +746,29 @@ namespace etl
       return *static_cast<type*>(data);
     }
 
+#if ETL_HAS_INITIALIZER_LIST
+    //***************************************************************************
+    /// Emplace by index with variadic constructor parameters.
+    //***************************************************************************
+    template <size_t Index, typename U, typename... TArgs>
+    typename etl::variant_alternative<Index, variant<TArgs...>>::type& emplace(std::initializer_list<U> il, TArgs&&... args)
+    {
+      static_assert(Index < etl::private_variant::parameter_pack<TTypes...>::size, "Index out of range");
+
+      using type = typename etl::private_variant::parameter_pack<TTypes...>::template type_from_index<Index>::type;
+
+      operation(private_variant::Destroy, data, nullptr);
+
+      construct_in_place_args<type>(data, il, etl::forward<TArgs>(args)...);
+
+      operation = operation_type<type, etl::is_copy_constructible<type>::value, etl::is_move_constructible<type>::value>::do_operation;
+
+      type_id = Index;
+
+      return *static_cast<type*>(data);
+    }
+#endif
+
     //***************************************************************************
     /// Move assignment operator for type.
     ///\param value The value to assign.
@@ -997,7 +1044,7 @@ namespace etl
 
 #if ETL_USING_CPP17 && !defined(ETL_VARIANT_FORCE_CPP11)
     //***************************************************************************
-    /// Call the relevent visitor by attempting each one.
+    /// Call the relevant visitor by attempting each one.
     //***************************************************************************
     template <typename TVisitor, size_t... I>
     void do_visitor(TVisitor& visitor, etl::index_sequence<I...>)
@@ -1006,7 +1053,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Call the relevent visitor by attempting each one.
+    /// Call the relevant visitor by attempting each one.
     //***************************************************************************
     template <typename TVisitor, size_t... I>
     void do_visitor(TVisitor& visitor, etl::index_sequence<I...>) const
@@ -1015,7 +1062,7 @@ namespace etl
     }
 #else
     //***************************************************************************
-    /// /// Call the relevent visitor.
+    /// /// Call the relevant visitor.
     //***************************************************************************
     template <typename TVisitor>
     void do_visitor(TVisitor& visitor)
@@ -1065,7 +1112,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// /// Call the relevent visitor.
+    /// /// Call the relevant visitor.
     //***************************************************************************
     template <typename TVisitor>
     void do_visitor(TVisitor& visitor) const
@@ -1125,7 +1172,7 @@ namespace etl
       {
         // Workaround for MSVC (2023/05/13)
         // It doesn't compile 'visitor.visit(etl::get<Index>(*this))' correctly for C++17 & C++20.
-        // Changed all of the instances for consistancy.
+        // Changed all of the instances for consistency.
         auto& v = etl::get<Index>(*this);
         visitor.visit(v);
         return true;
@@ -1146,7 +1193,7 @@ namespace etl
       {
         // Workaround for MSVC (2023/05/13)
         // It doesn't compile 'visitor.visit(etl::get<Index>(*this))' correctly for C++17 & C++20.
-        // Changed all of the instances for consistancy.
+        // Changed all of the instances for consistency.
         auto& v = etl::get<Index>(*this);
         visitor.visit(v);
         return true;
@@ -1159,7 +1206,7 @@ namespace etl
 
 #if ETL_USING_CPP17 && !defined(ETL_VARIANT_FORCE_CPP11)
     //***************************************************************************
-    /// Call the relevent visitor by attempting each one.
+    /// Call the relevant visitor by attempting each one.
     //***************************************************************************
     template <typename TVisitor, size_t... I>
     void do_operator(TVisitor& visitor, etl::index_sequence<I...>)
@@ -1168,7 +1215,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Call the relevent visitor by attempting each one.
+    /// Call the relevant visitor by attempting each one.
     //***************************************************************************
     template <typename TVisitor, size_t... I>
     void do_operator(TVisitor& visitor, etl::index_sequence<I...>) const
@@ -1177,7 +1224,7 @@ namespace etl
     }
 #else
     //***************************************************************************
-    /// Call the relevent visitor.
+    /// Call the relevant visitor.
     //***************************************************************************
     template <typename TVisitor>
     void do_operator(TVisitor& visitor)
@@ -1241,7 +1288,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Call the relevent visitor.
+    /// Call the relevant visitor.
     //***************************************************************************
     template <typename TVisitor>
     void do_operator(TVisitor& visitor) const
@@ -1693,7 +1740,7 @@ namespace etl
 
     //***************************************************************************
     /// Helper to instantiate the function pointers needed for the "jump table".
-    /// Embedds the 'TVarRest' (remaining variants) into its type to come around
+    /// Embeds the 'TVarRest' (remaining variants) into its type to come around
     /// the "double expansion" otherwise needed in "do_visit".
     //***************************************************************************
     template <typename TRet, typename TCallable, typename TCurVariant, typename... TVarRest>
@@ -1770,7 +1817,7 @@ namespace etl
   }  // namespace private_variant
 
   //***************************************************************************
-  /// c++11/14 compatible etl::visit for etl::variant. Supports both c++17
+  /// C++11/14 compatible etl::visit for etl::variant. Supports both c++17
   /// "auto return type" signature and c++20 explicit template return type.
   //***************************************************************************
   template <typename TRet = private_variant::visit_auto_return, typename... TVariants, typename TCallable, typename TDeducedReturn = private_variant::visit_result_t<TRet, TCallable, TVariants...> >
@@ -1778,5 +1825,221 @@ namespace etl
   {
     return private_variant::visit<TDeducedReturn>(static_cast<TCallable&&>(f), static_cast<TVariants&&>(vs)...);
   }
+
+  namespace private_variant
+  {
+    //***************************************************************************
+    /// C++11 compatible visitor function for testing variant equality.
+    /// Assumes that the two variants are already known to contain the same type.
+    //***************************************************************************
+    template <typename TVariant>
+    struct equality_visitor
+    {
+      equality_visitor(const TVariant& rhs_)
+        : rhs(rhs_)
+      {
+      }
+
+      template <typename TValue>
+      bool operator()(const TValue& lhs_downcasted)
+      {
+        return lhs_downcasted == etl::get<TValue>(rhs);
+      }
+
+      const TVariant& rhs;
+    };
+
+    //***************************************************************************
+    /// C++11 compatible visitor function for testing variant '<' (less than).
+    /// Assumes that the two variants are already known to contain the same type.
+    //***************************************************************************
+    template <typename TVariant>
+    struct less_than_visitor
+    {
+      less_than_visitor(const TVariant& rhs_)
+        : rhs(rhs_)
+      {
+      }
+
+      template <typename TValue>
+      bool operator()(const TValue& lhs_downcasted)
+      {
+        return lhs_downcasted < etl::get<TValue>(rhs);
+      }
+
+      const TVariant& rhs;
+    };
+  }
+
+  //***************************************************************************
+  /// Checks if the variants are equal.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator ==(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    // If both variants are valueless, they are considered equal
+    if (lhs.valueless_by_exception() && rhs.valueless_by_exception())
+    {
+      return true;
+    }
+
+    // If one variant is valueless and the other is not, they are not equal
+    if (lhs.valueless_by_exception() || rhs.valueless_by_exception())
+    {
+      return false;
+    }
+
+    // If variants have different types, they are not equal
+    if (lhs.index() != rhs.index())
+    {
+      return false;
+    }
+
+    // Variants have the same type, apply the equality operator for the contained values
+    private_variant::equality_visitor<etl::variant<TTypes...>> visitor(rhs);
+
+    return etl::visit(visitor, lhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the variants not equal.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator !=(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the lhs variant is less than rhs.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator <(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    // If both variants are valueless, they are considered equal, so not less than
+    if (lhs.valueless_by_exception() && rhs.valueless_by_exception())
+    {
+      return false;
+    }
+
+    // A valueless variant is always less than a variant with a value
+    if (lhs.valueless_by_exception())
+    {
+      return true;
+    }
+
+    // A variant with a value is never less than a valueless variant
+    if (rhs.valueless_by_exception())
+    {
+      return false;
+    }
+
+    // If variants have different types, compare the type index
+    if (lhs.index() != rhs.index())
+    {
+      return lhs.index() < rhs.index();
+    }
+
+    // Variants have the same type, apply the less than operator for the contained values
+    private_variant::less_than_visitor<etl::variant<TTypes...>> visitor(rhs);
+
+    return etl::visit(visitor, lhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the lhs variant is greater than rhs.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator >(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    return (rhs < lhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the lhs variant is less than or equal to rhs.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator <=(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    return  !(lhs > rhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the lhs variant is greater than or equal to rhs.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator >=(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    return !(lhs < rhs);
+  }
+
+  namespace private_variant
+  {
+#if ETL_USING_CPP20 && ETL_USING_STL
+    //***************************************************************************
+    /// C++20 compatible visitor function for testing variant '<=>'.
+    /// Assumes that the two variants are already known to contain the same type.
+    //***************************************************************************
+    template <typename TVariant>
+    struct compare_visitor
+    {
+      compare_visitor(const TVariant& rhs_)
+        : rhs(rhs_)
+      {
+      }
+
+      template <typename TValue>
+      std::strong_ordering operator()(const TValue& lhs_downcasted)
+      {
+        return lhs_downcasted <=> etl::get<TValue>(rhs);
+      }
+
+      const TVariant& rhs;
+    };
+#endif
+  }
+
+  //***************************************************************************
+  /// Defines the 'spaceship' <=> operator for comparing variants.
+  /// Only defined if using C++20 and STL.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+#if ETL_USING_CPP20 && ETL_USING_STL && !(defined(ETL_DEVELOPMENT_OS_APPLE) && defined(ETL_COMPILER_CLANG))
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 
+  std::common_comparison_category_t<std::compare_three_way_result_t<TTypes>...>
+    operator <=>(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    if (lhs.valueless_by_exception() && rhs.valueless_by_exception())
+    {
+      return std::strong_ordering::equal;
+    }
+    else if (lhs.valueless_by_exception())
+    {
+      return std::strong_ordering::less;
+    }
+    else if (rhs.valueless_by_exception())
+    {
+      return std::strong_ordering::greater;
+    }
+    else if (lhs.index() != rhs.index())
+    {
+      return lhs.index() <=> rhs.index();
+    }
+    else
+    {
+      // Variants have the same type, apply the equality operator for the contained values
+      private_variant::compare_visitor<etl::variant<TTypes...>> visitor(rhs);
+
+      return etl::visit(visitor, lhs);
+    }
+  }
+#endif
 }
 #endif
diff --git a/include/etl/queue_spsc_locked.h b/include/etl/queue_spsc_locked.h
index a5e7ca1f..0ac26b5d 100644
--- a/include/etl/queue_spsc_locked.h
+++ b/include/etl/queue_spsc_locked.h
@@ -868,9 +868,9 @@ namespace etl
     /// Default constructor.
     //*************************************************************************
 
-    queue_spsc_locked(const etl::ifunction<void>& lock,
-                      const etl::ifunction<void>& unlock)
-      : base_t(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, lock, unlock)
+    queue_spsc_locked(const etl::ifunction<void>& lock_,
+                      const etl::ifunction<void>& unlock_)
+      : base_t(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, lock_, unlock_)
     {
     }
 
diff --git a/include/etl/radix.h b/include/etl/radix.h
index 63bf47f3..88a62738 100644
--- a/include/etl/radix.h
+++ b/include/etl/radix.h
@@ -47,19 +47,19 @@ namespace etl
   {
     enum enum_type
     {
-      undefined = 0,
-      binary    = 2,
-      octal     = 8,
-      decimal   = 10,
-      hex       = 16
+      undefined   = 0,
+      binary      = 2,
+      octal       = 8,
+      decimal     = 10,
+      hexadecimal = 16
     };
 
     ETL_DECLARE_ENUM_TYPE(radix, uint_least8_t)
-    ETL_ENUM_TYPE(undefined, "undefined")
-    ETL_ENUM_TYPE(binary,    "binary")
-    ETL_ENUM_TYPE(octal,     "octal")
-    ETL_ENUM_TYPE(decimal,   "decimal")
-    ETL_ENUM_TYPE(hex,       "hex")
+    ETL_ENUM_TYPE(undefined,   "undefined")
+    ETL_ENUM_TYPE(binary,      "binary")
+    ETL_ENUM_TYPE(octal,       "octal")
+    ETL_ENUM_TYPE(decimal,     "decimal")
+    ETL_ENUM_TYPE(hexadecimal, "hexadecimal")
     ETL_END_ENUM_TYPE
   };
 }
diff --git a/include/etl/random.h b/include/etl/random.h
index e24bb84d..2a480506 100644
--- a/include/etl/random.h
+++ b/include/etl/random.h
@@ -462,12 +462,12 @@ namespace etl
 
     random_pcg()
     {
-#include "etl/private/diagnostic_useless_cast_push.h"
+#include "private/diagnostic_useless_cast_push.h"
       // An attempt to come up with a unique non-zero seed,
       // based on the address of the instance.
       uintptr_t n = reinterpret_cast<uintptr_t>(this);
       value = static_cast<uint64_t>(n);
-#include "etl/private/diagnostic_pop.h"
+#include "private/diagnostic_pop.h"
     }
 
     //***************************************************************************
diff --git a/include/etl/reference_counted_message.h b/include/etl/reference_counted_message.h
index 69c35e2f..fd615df1 100644
--- a/include/etl/reference_counted_message.h
+++ b/include/etl/reference_counted_message.h
@@ -69,14 +69,19 @@ namespace etl
     typedef TMessage message_type;
     typedef TCounter counter_type;
 
+#if ETL_USING_CPP11
     //***************************************************************************
     /// Constructor
     /// \param owner The message owner.
+    /// \param args  The constructor arguments.
     //***************************************************************************
-    reference_counted_message(etl::ireference_counted_message_pool& owner_)
-      : owner(owner_)
+    template <typename... TArgs>
+    reference_counted_message(etl::ireference_counted_message_pool& owner_, TArgs&&... args)
+      : rc_object(etl::forward<TArgs>(args)...)
+      , owner(owner_)
     {
     }
+#endif
 
     //***************************************************************************
     /// Constructor
@@ -222,4 +227,4 @@ namespace etl
 #endif
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/include/etl/reference_counted_message_pool.h b/include/etl/reference_counted_message_pool.h
index d678f9fe..fe18a1ee 100644
--- a/include/etl/reference_counted_message_pool.h
+++ b/include/etl/reference_counted_message_pool.h
@@ -100,6 +100,35 @@ namespace etl
     {
     }
 
+#if ETL_USING_CPP11
+    //*************************************************************************
+    /// Allocate a reference counted message from the pool.
+    //*************************************************************************
+    template <typename TMessage, typename... TArgs>
+    etl::reference_counted_message<TMessage, TCounter>* allocate(TArgs&&... args)
+    {
+      ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage>::value), "Not a message type");
+
+      typedef etl::reference_counted_message<TMessage, TCounter> rcm_t;
+      typedef rcm_t* prcm_t;
+
+      prcm_t p = ETL_NULLPTR;
+
+      lock();
+      p = static_cast<prcm_t>(memory_block_allocator.allocate(sizeof(rcm_t), etl::alignment_of<rcm_t>::value));
+      unlock();
+
+      if (p != ETL_NULLPTR)
+      {
+        ::new(p) rcm_t(*this, etl::forward<TArgs>(args)...);
+      }
+
+      ETL_ASSERT((p != ETL_NULLPTR), ETL_ERROR(etl::reference_counted_message_pool_allocation_failure));
+
+      return p;
+    }
+#endif
+
     //*************************************************************************
     /// Allocate a reference counted message from the pool.
     //*************************************************************************
@@ -182,13 +211,13 @@ namespace etl
       // Size of the first pool message type.
       static constexpr size_t size1 = sizeof(etl::reference_counted_message<TMessage1, TCounter>);
 
-      // Maximum size of the the rest of the pool message types.
+      // Maximum size of the rest of the pool message types.
       static constexpr size_t size2 = pool_message_parameters<TMessages...>::max_size;
 
       // Size of the first pool message type.
       static constexpr size_t alignment1 = etl::alignment_of<etl::reference_counted_message<TMessage1, TCounter>>::value;
 
-      // Maximum size of the the rest of the pool message types.
+      // Maximum size of the rest of the pool message types.
       static constexpr size_t alignment2 = pool_message_parameters<TMessages...>::max_alignment;
 
     public:
@@ -216,8 +245,8 @@ namespace etl
     };
 
 #else
-    template <typename TMessage1,              typename TMessage2  = TMessage1, typename TMessage3  = TMessage1, typename TMessage4  = TMessage1,
-              typename TMessage5  = TMessage1, typename TMessage6  = TMessage1, typename TMessage7  = TMessage1, typename TMessage8  = TMessage1>
+    template <typename TMessage1,             typename TMessage2 = TMessage1, typename TMessage3 = TMessage1, typename TMessage4 = TMessage1,
+              typename TMessage5 = TMessage1, typename TMessage6 = TMessage1, typename TMessage7 = TMessage1, typename TMessage8 = TMessage1>
     struct pool_message_parameters
     {
       ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage1>::value), "TMessage1 not derived from etl::imessage");
@@ -230,23 +259,23 @@ namespace etl
       ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage1>::value), "TMessage8 not derived from etl::imessage");
 
       static ETL_CONSTANT size_t max_size = etl::largest<etl::reference_counted_message<TMessage1, TCounter>,
-                                                  etl::reference_counted_message<TMessage2, TCounter>,
-                                                  etl::reference_counted_message<TMessage3, TCounter>,
-                                                  etl::reference_counted_message<TMessage4, TCounter>,
-                                                  etl::reference_counted_message<TMessage5, TCounter>,
-                                                  etl::reference_counted_message<TMessage6, TCounter>,
-                                                  etl::reference_counted_message<TMessage7, TCounter>,
-                                                  etl::reference_counted_message<TMessage8, TCounter> >::size;
+                                                         etl::reference_counted_message<TMessage2, TCounter>,
+                                                         etl::reference_counted_message<TMessage3, TCounter>,
+                                                         etl::reference_counted_message<TMessage4, TCounter>,
+                                                         etl::reference_counted_message<TMessage5, TCounter>,
+                                                         etl::reference_counted_message<TMessage6, TCounter>,
+                                                         etl::reference_counted_message<TMessage7, TCounter>,
+                                                         etl::reference_counted_message<TMessage8, TCounter> >::size;
 
 
       static ETL_CONSTANT size_t max_alignment = etl::largest<etl::reference_counted_message<TMessage1, TCounter>,
-                                                       etl::reference_counted_message<TMessage2, TCounter>,
-                                                       etl::reference_counted_message<TMessage3, TCounter>,
-                                                       etl::reference_counted_message<TMessage4, TCounter>,
-                                                       etl::reference_counted_message<TMessage5, TCounter>,
-                                                       etl::reference_counted_message<TMessage6, TCounter>,
-                                                       etl::reference_counted_message<TMessage7, TCounter>,
-                                                       etl::reference_counted_message<TMessage8, TCounter> >::alignment;
+                                                              etl::reference_counted_message<TMessage2, TCounter>,
+                                                              etl::reference_counted_message<TMessage3, TCounter>,
+                                                              etl::reference_counted_message<TMessage4, TCounter>,
+                                                              etl::reference_counted_message<TMessage5, TCounter>,
+                                                              etl::reference_counted_message<TMessage6, TCounter>,
+                                                              etl::reference_counted_message<TMessage7, TCounter>,
+                                                              etl::reference_counted_message<TMessage8, TCounter> >::alignment;
     };
 
 #endif
@@ -290,4 +319,4 @@ namespace etl
 #endif
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/include/etl/reference_counted_object.h b/include/etl/reference_counted_object.h
index e3458611..198da27a 100644
--- a/include/etl/reference_counted_object.h
+++ b/include/etl/reference_counted_object.h
@@ -33,6 +33,7 @@
 #include "atomic.h"
 #include "exception.h"
 #include "error_handler.h"
+#include "utility.h"
 
 #include <stdint.h>
 
@@ -223,6 +224,17 @@ namespace etl
     {
     }
 
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Constructor.
+    //***************************************************************************
+    template <typename... TArgs>
+    reference_counted_object(TArgs&&... args)
+      : object(etl::forward<TArgs>(args)...)
+    {
+    }
+#endif
+
     //***************************************************************************
     /// Get a reference to the counted object.
     //***************************************************************************
@@ -276,4 +288,4 @@ namespace etl
 #endif
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/include/etl/set.h b/include/etl/set.h
index b3babaa2..6dac5d54 100644
--- a/include/etl/set.h
+++ b/include/etl/set.h
@@ -1407,10 +1407,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(const_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new ((void*)&node.value) value_type(value);
+      Data_Node* node = allocate_data_node();
+      ::new ((void*)&node->value) value_type(value);
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #if ETL_USING_CPP11
@@ -1419,20 +1419,20 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(rvalue_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new ((void*)&node.value) value_type(etl::move(value));
+      Data_Node* node = allocate_data_node();
+      ::new ((void*)&node->value) value_type(etl::move(value));
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 #endif
 
     //*************************************************************************
     /// Create a Data_Node.
     //*************************************************************************
-    Data_Node& allocate_data_node()
+    Data_Node* allocate_data_node()
     {
       Data_Node* (etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
-      return *(p_node_pool->*func)();
+      return (p_node_pool->*func)();
     }
 
     //*************************************************************************
diff --git a/include/etl/shared_message.h b/include/etl/shared_message.h
index 013ea887..43d8f783 100644
--- a/include/etl/shared_message.h
+++ b/include/etl/shared_message.h
@@ -49,6 +49,17 @@ namespace etl
   {
   public:
 
+#if ETL_USING_CPP11
+    //*************************************************************************
+    /// Creator for in-place instantiation
+    //*************************************************************************
+    template <typename TMessage, typename TPool, typename... TArgs>
+    static shared_message create(TPool& owner, TArgs&&... args)
+    {
+      return shared_message(owner, etl::in_place_type_t<TMessage>(), etl::forward<TArgs>(args)...);
+    }
+#endif
+
     //*************************************************************************
     /// Constructor
     //*************************************************************************
@@ -59,13 +70,32 @@ namespace etl
       ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage>::value), "TMessage not derived from etl::imessage");
 
       p_rcmessage = owner.allocate(message);
-      
+
       if (p_rcmessage != ETL_NULLPTR)
       {
         p_rcmessage->get_reference_counter().set_reference_count(1U);
       }
     }
 
+#if ETL_USING_CPP11
+    //*************************************************************************
+    /// Constructor
+    //*************************************************************************
+    template <typename TPool, typename TMessage, typename... TArgs>
+    shared_message(TPool& owner, etl::in_place_type_t<TMessage>, TArgs&&... args)
+    {
+      ETL_STATIC_ASSERT((etl::is_base_of<etl::ireference_counted_message_pool, TPool>::value), "TPool not derived from etl::ireference_counted_message_pool");
+      ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage>::value), "TMessage not derived from etl::imessage");
+
+      p_rcmessage = owner.template allocate<TMessage>(etl::forward<TArgs>(args)...);
+
+      if (p_rcmessage != ETL_NULLPTR)
+      {
+        p_rcmessage->get_reference_counter().set_reference_count(1U);
+      }
+    }
+#endif
+
     //*************************************************************************
     /// Constructor
     //*************************************************************************
@@ -193,5 +223,4 @@ namespace etl
   };
 }
 
-#endif
-
+#endif
\ No newline at end of file
diff --git a/include/etl/span.h b/include/etl/span.h
index 797e35e5..f1077ea7 100644
--- a/include/etl/span.h
+++ b/include/etl/span.h
@@ -42,6 +42,7 @@ SOFTWARE.
 #include "memory.h"
 #include "array.h"
 #include "byte.h"
+#include "static_assert.h"
 
 #include "private/dynamic_extent.h"
 
@@ -78,14 +79,6 @@ namespace etl
 
     static ETL_CONSTANT size_t extent = Extent;
 
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR span() ETL_NOEXCEPT
-      : pbegin(ETL_NULLPTR)
-    {
-    }
-
     //*************************************************************************
     /// Construct from iterators + size
     //*************************************************************************
@@ -295,6 +288,9 @@ namespace etl
     template <size_t COUNT>
     ETL_NODISCARD ETL_CONSTEXPR etl::span<element_type, COUNT> first() const ETL_NOEXCEPT
     {
+      // If Extent is static, check that original span contains at least COUNT elements
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) ? COUNT <= Extent : true, "Original span does not contain COUNT elements");
+
       return etl::span<element_type, COUNT>(pbegin, pbegin + COUNT);
     }
 
@@ -312,6 +308,9 @@ namespace etl
     template <size_t COUNT>
     ETL_NODISCARD ETL_CONSTEXPR etl::span<element_type, COUNT> last() const ETL_NOEXCEPT
     {
+      // If Extent is static, check that original span contains at least COUNT elements
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) ? COUNT <= Extent : true, "Original span does not contain COUNT elements");
+
       return etl::span<element_type, COUNT>(pbegin + Extent - COUNT, (pbegin + Extent));
     }
 
@@ -331,6 +330,12 @@ namespace etl
     ETL_NODISCARD ETL_CONSTEXPR
     etl::span<element_type, COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET> subspan() const ETL_NOEXCEPT
     {
+      // If Extent is static, check that OFFSET is within the original span
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) ? OFFSET <= Extent : true, "OFFSET is not within the original span");
+
+      // If count is also static, check that OFFSET + COUNT is within the original span
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) && (COUNT != etl::dynamic_extent) ? COUNT <= (Extent - OFFSET) : true, "OFFSET + COUNT is not within the original span");
+      
       return (COUNT == etl::dynamic_extent) ? etl::span<element_type, COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET>(pbegin + OFFSET, (pbegin + Extent))
                                             : etl::span<element_type, COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET>(pbegin + OFFSET, pbegin + OFFSET + COUNT);
     }
@@ -341,6 +346,12 @@ namespace etl
     template <size_t OFFSET, size_t COUNT>
     etl::span<element_type, COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET> subspan() const
     {
+      // If Extent is static, check that OFFSET is within the original span
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) ? OFFSET <= Extent : true, "OFFSET is not within the original span");
+
+      // If count is also static, check that OFFSET + COUNT is within the original span
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) && (COUNT != etl::dynamic_extent) ? COUNT <= (Extent - OFFSET) : true, "OFFSET + COUNT is not within the original span");
+      
       if (COUNT == etl::dynamic_extent)
       {
         return etl::span<element_type, (COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET)>(pbegin + OFFSET, (pbegin + Extent));
@@ -720,7 +731,7 @@ namespace etl
 
   //*************************************************************************
   /// Equality function.
-  /// Performs a comparision of the range values.
+  /// Performs a comparison of the range values.
   /// Returns <b>true</b> if one of the following are <b>true</b>
   /// 1. Both spans are empty.
   /// 2. They both point to the same range of data.
diff --git a/include/etl/string.h b/include/etl/string.h
index 5f925337..1fbc19d2 100644
--- a/include/etl/string.h
+++ b/include/etl/string.h
@@ -246,9 +246,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::istring::repair_buffer(buffer);
@@ -434,9 +435,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/string_view.h b/include/etl/string_view.h
index a196b908..7ddce503 100644
--- a/include/etl/string_view.h
+++ b/include/etl/string_view.h
@@ -662,6 +662,7 @@ namespace etl
             if (mbegin[i] == view[j])
             {
               found = true;
+              break;
             }
           }
 
@@ -715,6 +716,7 @@ namespace etl
           if (mbegin[position] == view[j])
           {
             found = true;
+            break;
           }
         }
 
diff --git a/include/etl/timer.h b/include/etl/timer.h
index 856413b0..ed96cdec 100644
--- a/include/etl/timer.h
+++ b/include/etl/timer.h
@@ -104,6 +104,17 @@ namespace etl
         Inactive = 0xFFFFFFFFUL
       };
     };
+
+    // Timer time interval.
+    struct interval
+    {
+      enum
+      {
+        No_Active_Interval = 0xFFFFFFFFUL
+      };
+
+      typedef uint32_t type;
+    };
   };
 }
 
diff --git a/include/etl/to_arithmetic.h b/include/etl/to_arithmetic.h
index f2e69743..c7b2632f 100644
--- a/include/etl/to_arithmetic.h
+++ b/include/etl/to_arithmetic.h
@@ -251,7 +251,7 @@ namespace etl
           break;
         }
 
-        case etl::radix::hex:
+        case etl::radix::hexadecimal:
         {
           return ((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f'));
           break;
@@ -281,7 +281,7 @@ namespace etl
           break;
         }
 
-        case etl::radix::hex:
+        case etl::radix::hexadecimal:
         {
           if ((c >= '0') && (c <= '9'))
           {
@@ -363,7 +363,7 @@ namespace etl
       return (radix == etl::radix::binary)  ||
              (radix == etl::radix::octal)   ||
              (radix == etl::radix::decimal) ||
-             (radix == etl::radix::hex);
+             (radix == etl::radix::hexadecimal);
     }
 
     //***************************************************************************
@@ -397,7 +397,7 @@ namespace etl
           TValue old_value = integral_value;
           integral_value *= radix;
 
-          // No multipication overflow?
+          // No multiplication overflow?
           is_not_overflow = ((integral_value / radix) == old_value);
 
           if (is_not_overflow)
diff --git a/include/etl/type_def.h b/include/etl/type_def.h
index d16e4cd9..c124aa7e 100644
--- a/include/etl/type_def.h
+++ b/include/etl/type_def.h
@@ -35,274 +35,262 @@ SOFTWARE.
 
 namespace etl
 {
-    #define ETL_TYPEDEF(T, name) class name##_tag; typedef etl::type_def<name##_tag, T> name
+  #define ETL_TYPEDEF(T, name) class name##_tag; typedef etl::type_def<name##_tag, T> name
 
-    //*************************************************************************
-    /// A template type to define strong typedefs.
-    /// Usage:
-    ///\code
-    /// // Short form.
-    /// ETL_TYPEDEF(int, mytype);
-    ///
-    /// // Long form.
-    /// class mytype_t_tag;
-    /// typedef etl::type_def<mytype_t_tag, int> mytype_t_tag;
-    ///\endcode
-    //*************************************************************************
-    template <typename TIdType, typename TValue>
-    class type_def
+  //*************************************************************************
+  /// A template type to define strong typedefs.
+  /// Usage:
+  ///\code
+  /// // Short form.
+  /// ETL_TYPEDEF(int, mytype);
+  ///
+  /// // Long form.
+  /// class mytype_t_tag;
+  /// typedef etl::type_def<mytype_t_tag, int> mytype_t_tag;
+  ///\endcode
+  //*************************************************************************
+  template <typename TIdType, typename TValue>
+  class type_def
+  {
+  public:
+
+    typedef TValue  value_type;
+    typedef TIdType id_type;
+
+    //*********************************************************************
+    ETL_CONSTEXPR type_def()
+      : value(TValue())
     {
-    public:
+    }
 
-        typedef TValue  value_type;
-        typedef TIdType id_type;
+    //*********************************************************************
+    ETL_CONSTEXPR type_def(TValue value_)
+      : value(value_)
+    {
+    }
 
-        //*********************************************************************
-        type_def()
-            : value(TValue())
-        {
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR type_def(const type_def& other)
+      : value(other.value)
+    {
+    }
 
-        //*********************************************************************
-        type_def(TValue value_)
-            : value(value_)
-        {
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR operator TValue() const
+    {
+      return value;
+    }
 
-        //*********************************************************************
-        type_def(const type_def& other)
-            : value(other.value)
-        {
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator ++()
+    {
+      ++value;
+      return *this;
+    }
 
-        //*********************************************************************
-        operator TValue() const
-        {
-            return value;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def operator ++(int)
+    {
+      type_def temp(*this);
+      type_def::operator ++();
+      return temp;
+    }
 
-        //*********************************************************************
-        type_def& operator ++()
-        {
-            ++value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator --()
+    {
+      --value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def operator ++(int)
-        {
-            type_def temp(*this);
-            type_def::operator ++();
-            return temp;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def operator --(int)
+    {
+      type_def temp(*this);
+      type_def::operator --();
+      return temp;
+    }
 
-        //*********************************************************************
-        type_def& operator --()
-        {
-            --value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator +=(TValue rhs)
+    {
+      value += rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def operator --(int)
-        {
-            type_def temp(*this);
-            type_def::operator --();
-            return temp;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator +=(const type_def& rhs)
+    {
+      value += rhs.value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator +=(TValue rhs)
-        {
-            value += rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator -=(TValue rhs)
+    {
+      value -= rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator +=(const type_def& rhs)
-        {
-            value += rhs.value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator -=(const type_def& rhs)
+    {
+      value -= rhs.value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator -=(TValue rhs)
-        {
-            value -= rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator *=(TValue rhs)
+    {
+      value *= rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator -=(const type_def& rhs)
-        {
-            value -= rhs.value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator *=(const type_def& rhs)
+    {
+      value *= rhs.value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator *=(TValue rhs)
-        {
-            value *= rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator /=(TValue rhs)
+    {
+      value /= rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator *=(const type_def& rhs)
-        {
-            value *= rhs.value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator /=(const type_def& rhs)
+    {
+      value /= rhs.value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator /=(TValue rhs)
-        {
-            value /= rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator %=(TValue rhs)
+    {
+      value %= rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator /=(const type_def& rhs)
-        {
-            value /= rhs.value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator %=(const type_def& rhs)
+    {
+      value %= rhs.value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator %=(TValue rhs)
-        {
-            value %= rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator &=(TValue rhs)
+    {
+      value &= rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator %=(const type_def& rhs)
-        {
-            value %= rhs.value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator &=(const type_def& rhs)
+    {
+      value &= rhs.value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator &=(TValue rhs)
-        {
-            value &= rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator |=(TValue rhs)
+    {
+      value |= rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator &=(const type_def& rhs)
-        {
-            value &= rhs.value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator |=(const type_def& rhs)
+    {
+      value |= rhs.value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator |=(TValue rhs)
-        {
-            value |= rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator ^=(TValue rhs)
+    {
+      value ^= rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator |=(const type_def& rhs)
-        {
-            value |= rhs.value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator ^=(const type_def& rhs)
+    {
+      value ^= rhs.value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator ^=(TValue rhs)
-        {
-            value ^= rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator <<=(TValue rhs)
+    {
+      value <<= rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator ^=(const type_def& rhs)
-        {
-            value ^= rhs.value;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator >>=(TValue rhs)
+    {
+      value >>= rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator <<=(TValue rhs)
-        {
-            value <<= rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator =(TValue rhs)
+    {
+      value = rhs;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator >>=(TValue rhs)
-        {
-            value >>= rhs;
-            return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator =(const type_def& rhs)
+    {
+      value = rhs.value;
+      return *this;
+    }
 
-        //*********************************************************************
-        type_def& operator =(TValue rhs)
-        {
-            value = rhs;
-            return *this;
-        }
+    //*********************************************************************
+    TValue& get()
+    {
+      return value;
+    }
 
-        //*********************************************************************
-        type_def& operator =(const type_def& rhs)
-        {
-          value = rhs.value;
-          return *this;
-        }
+    //*********************************************************************
+    ETL_CONSTEXPR const TValue& get() const
+    {
+      return value;
+    }
 
-        //*********************************************************************
-        TValue& get()
-        {
-            return value;
-        }
+    //*********************************************************************
+    friend ETL_CONSTEXPR bool operator >(const type_def& lhs, const type_def& rhs)
+    {
+      return lhs.value > rhs.value;
+    }
 
-        //*********************************************************************
-        const TValue& get() const
-        {
-            return value;
-        }
+    //*********************************************************************
+    friend ETL_CONSTEXPR bool operator >=(const type_def& lhs, const type_def& rhs)
+    {
+      return lhs.value >= rhs.value;
+    }
 
-        //*********************************************************************
-        friend bool operator <(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value < rhs.value;
-        }
+    //*********************************************************************
+    friend ETL_CONSTEXPR bool operator ==(const type_def& lhs, const type_def& rhs)
+    {
+      return lhs.value == rhs.value;
+    }
 
-        //*********************************************************************
-        friend bool operator <=(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value <= rhs.value;
-        }
+    //*********************************************************************
+    friend ETL_CONSTEXPR bool operator !=(const type_def& lhs, const type_def& rhs)
+    {
+      return lhs.value != rhs.value;
+    }
 
-        //*********************************************************************
-        friend bool operator >(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value > rhs.value;
-        }
+  private:
 
-        //*********************************************************************
-        friend bool operator >=(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value >= rhs.value;
-        }
-
-        //*********************************************************************
-        friend bool operator ==(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value == rhs.value;
-        }
-
-        //*********************************************************************
-        friend bool operator !=(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value != rhs.value;
-        }
-
-    private:
-
-        TValue value;
-    };
+      TValue value;
+  };
 }
 
 #endif
diff --git a/include/etl/type_traits.h b/include/etl/type_traits.h
index cb4fc726..43f01de3 100644
--- a/include/etl/type_traits.h
+++ b/include/etl/type_traits.h
@@ -62,7 +62,7 @@ SOFTWARE.
 
 ///\defgroup type_traits type_traits
 /// A set of type traits definitions.
-/// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined.
+/// Derived from either the standard or alternate definitions, dependent on whether or not ETL_NO_STL is defined.
 /// \ingroup utilities
 
 #if ETL_USING_STL && ETL_USING_CPP11
@@ -2070,6 +2070,21 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
+#if ETL_USING_CPP11
+  //*********************************************
+  // is_default_constructible
+  template<typename T, typename = void>
+  struct is_default_constructible : etl::false_type { };
+
+  template<typename T>
+  struct is_default_constructible<T, etl::void_t<decltype(T())>> : etl::true_type { };
+#else
+  template <typename T>
+  struct is_default_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
+  {
+  };
+#endif
+
 #if ETL_USING_CPP17
 
   template <typename T1, typename T2>
@@ -2081,6 +2096,9 @@ typedef integral_constant<bool, true>  true_type;
   template<typename T, typename... TArgs>
   inline constexpr bool is_constructible_v = etl::is_constructible<T, TArgs...>::value;
 
+  template<typename T, typename... TArgs>
+  inline constexpr bool is_default_constructible_v = etl::is_default_constructible<T, TArgs...>::value;
+
   template<typename T>
   inline constexpr bool is_copy_constructible_v = etl::is_copy_constructible<T>::value;
 
diff --git a/include/etl/u16string.h b/include/etl/u16string.h
index 2c100c8b..c0fea3a2 100644
--- a/include/etl/u16string.h
+++ b/include/etl/u16string.h
@@ -230,9 +230,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu16string::repair_buffer(buffer);
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/u32string.h b/include/etl/u32string.h
index 88d0ed44..766a0cbc 100644
--- a/include/etl/u32string.h
+++ b/include/etl/u32string.h
@@ -230,9 +230,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu32string::repair_buffer(buffer);
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/u8string.h b/include/etl/u8string.h
index 9d8b9458..015ef3c1 100644
--- a/include/etl/u8string.h
+++ b/include/etl/u8string.h
@@ -247,9 +247,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu8string::repair_buffer(buffer);
@@ -435,9 +436,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/include/etl/unordered_map.h b/include/etl/unordered_map.h
index 0e5b9e35..fab74e86 100644
--- a/include/etl/unordered_map.h
+++ b/include/etl/unordered_map.h
@@ -659,13 +659,13 @@ namespace etl
 
       // Doesn't exist, so add a new one.
       // Get a new node.
-      node_t& node = allocate_data_node();
-      node.clear();
-      ::new ((void*)etl::addressof(node.key_value_pair.first))  key_type(etl::move(key));
-      ::new ((void*)etl::addressof(node.key_value_pair.second)) mapped_type();
+      node_t* node = allocate_data_node();
+      node->clear();
+      ::new ((void*)etl::addressof(node->key_value_pair.first))  key_type(etl::move(key));
+      ::new ((void*)etl::addressof(node->key_value_pair.second)) mapped_type();
       ETL_INCREMENT_DEBUG_COUNT;
 
-      pbucket->insert_after(pbucket->before_begin(), node);
+      pbucket->insert_after(pbucket->before_begin(), *node);
 
       adjust_first_last_markers_after_insert(pbucket);
 
@@ -703,13 +703,13 @@ namespace etl
 
       // Doesn't exist, so add a new one.
       // Get a new node.
-      node_t& node = allocate_data_node();
-      node.clear();
-      ::new ((void*)etl::addressof(node.key_value_pair.first))  key_type(key);
-      ::new ((void*)etl::addressof(node.key_value_pair.second)) mapped_type();
+      node_t* node = allocate_data_node();
+      node->clear();
+      ::new ((void*)etl::addressof(node->key_value_pair.first))  key_type(key);
+      ::new ((void*)etl::addressof(node->key_value_pair.second)) mapped_type();
       ETL_INCREMENT_DEBUG_COUNT;
 
-        pbucket->insert_after(pbucket->before_begin(), node);
+        pbucket->insert_after(pbucket->before_begin(), *node);
 
       adjust_first_last_markers_after_insert(pbucket);
 
@@ -835,13 +835,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new ((void*)etl::addressof(node.key_value_pair)) value_type(key_value_pair);        
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new ((void*)etl::addressof(node->key_value_pair)) value_type(key_value_pair);        
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
 
         adjust_first_last_markers_after_insert(pbucket);
 
@@ -870,13 +870,13 @@ namespace etl
         if (inode == bucket.end())
         {
           // Get a new node.
-          node_t& node = allocate_data_node();
-          node.clear();
-          ::new ((void*)etl::addressof(node.key_value_pair)) value_type(key_value_pair);
+          node_t* node = allocate_data_node();
+          node->clear();
+          ::new ((void*)etl::addressof(node->key_value_pair)) value_type(key_value_pair);
           ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
           adjust_first_last_markers_after_insert(&bucket);
           ++inode_previous;
 
@@ -913,13 +913,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new ((void*)etl::addressof(node.key_value_pair)) value_type(etl::move(key_value_pair));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new ((void*)etl::addressof(node->key_value_pair)) value_type(etl::move(key_value_pair));
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
 
         adjust_first_last_markers_after_insert(pbucket);
 
@@ -948,13 +948,13 @@ namespace etl
         if (inode == bucket.end())
         {
           // Get a new node.
-          node_t& node = allocate_data_node();
-          node.clear();
-          ::new ((void*)etl::addressof(node.key_value_pair)) value_type(etl::move(key_value_pair));
+          node_t* node = allocate_data_node();
+          node->clear();
+          ::new ((void*)etl::addressof(node->key_value_pair)) value_type(etl::move(key_value_pair));
           ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
           adjust_first_last_markers_after_insert(&bucket);
           ++inode_previous;
 
@@ -1420,14 +1420,14 @@ namespace etl
     //*************************************************************************
     /// Move from a range
     //*************************************************************************
-    void move(iterator first, iterator last)
+    void move(iterator b, iterator e)
     {
-      while (first != last)
+      while (b != e)
       {
-        iterator temp = first;
+        iterator temp = b;
         ++temp;
-        insert(etl::move(*first));
-        first = temp;
+        insert(etl::move(*b));
+        b = temp;
       }
     }
 #endif
@@ -1437,10 +1437,10 @@ namespace etl
     //*************************************************************************
     /// Create a node.
     //*************************************************************************
-    node_t& allocate_data_node()
+    node_t* allocate_data_node()
     {
       node_t* (etl::ipool::*func)() = &etl::ipool::allocate<node_t>;
-      return *(pnodepool->*func)();
+      return (pnodepool->*func)();
     }
 
     //*********************************************************************
@@ -1489,26 +1489,26 @@ namespace etl
         else if (pbucket == last)
         {
           // We erased the last, so we need to search again. Start from the first, go no further than the current last.
-          bucket_t* pcurrent = first;
+          pbucket = first;
           bucket_t* pend = last;
 
           last = first;
 
-          while (pcurrent != pend)
+          while (pbucket != pend)
           {
-            if (!pcurrent->empty())
+            if (!pbucket->empty())
             {
-              last = pcurrent;
+              last = pbucket;
             }
 
-            ++pcurrent;
+            ++pbucket;
           }
         }
       }
     }
 
     //*********************************************************************
-    /// Delete a data noe at the specified location.
+    /// Delete a data node at the specified location.
     //*********************************************************************
     local_iterator delete_data_node(local_iterator iprevious, local_iterator icurrent, bucket_t& bucket)
     {
@@ -1569,20 +1569,41 @@ namespace etl
   ///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
   ///\ingroup unordered_map
   //***************************************************************************
-  template <typename TKey, typename T, typename TKeyCompare>
-  bool operator ==(const etl::iunordered_map<TKey, T, TKeyCompare>& lhs, const etl::iunordered_map<TKey, T, TKeyCompare>& rhs)
+  template <typename TKey, typename T, typename THash, typename TKeyEqual>
+  bool operator ==(const etl::iunordered_map<TKey, T, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_map<TKey, T, THash, TKeyEqual>& rhs)
   {
     const bool sizes_match = (lhs.size() == rhs.size());
     bool elements_match = true;
 
+    typedef typename etl::iunordered_map<TKey, T, THash, TKeyEqual>::const_iterator itr_t;
+    
     if (sizes_match)
     {
-      for (size_t i = 0; (i < lhs.bucket_count()) && elements_match; ++i)
+      itr_t l_begin = lhs.begin();
+      itr_t l_end   = lhs.end();
+
+      while ((l_begin != l_end) && elements_match)
       {
-        if (!etl::is_permutation(lhs.begin(i), lhs.end(i), rhs.begin(i)))
+        const TKey key     = l_begin->first;
+        const T    l_value = l_begin->second;
+
+        // See if the lhs key exists in the rhs.
+        ETL_OR_STD::pair<itr_t, itr_t> range = rhs.equal_range(key);
+
+        if (range.first != rhs.end())
+        {
+          // See if the values match
+          const T r_value = range.first->second;
+
+          elements_match = (r_value == l_value);
+        }
+        else
         {
           elements_match = false;
         }
+
+        ++l_begin;
       }
     }
 
@@ -1596,8 +1617,9 @@ namespace etl
   ///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
   ///\ingroup unordered_map
   //***************************************************************************
-  template <typename TKey, typename T, typename TKeyCompare>
-  bool operator !=(const etl::iunordered_map<TKey, T, TKeyCompare>& lhs, const etl::iunordered_map<TKey, T, TKeyCompare>& rhs)
+  template <typename TKey, typename T, typename THash, typename TKeyEqual>
+  bool operator !=(const etl::iunordered_map<TKey, T, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_map<TKey, T, THash, TKeyEqual>& rhs)
   {
     return !(lhs == rhs);
   }
diff --git a/include/etl/unordered_multimap.h b/include/etl/unordered_multimap.h
index 174b5978..53d9f43f 100644
--- a/include/etl/unordered_multimap.h
+++ b/include/etl/unordered_multimap.h
@@ -675,13 +675,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key_value_pair) value_type(key_value_pair);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key_value_pair) value_type(key_value_pair);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(pbucket);
 
         result = iterator((pbuckets + number_of_buckets), pbucket, pbucket->begin());
@@ -705,13 +705,13 @@ namespace etl
         }
 
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key_value_pair) value_type(key_value_pair);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key_value_pair) value_type(key_value_pair);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Add the node to the end of the bucket;
-        bucket.insert_after(inode_previous, node);
+        bucket.insert_after(inode_previous, *node);
         adjust_first_last_markers_after_insert(&bucket);
         ++inode_previous;
 
@@ -746,13 +746,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key_value_pair) value_type(etl::move(key_value_pair));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key_value_pair) value_type(etl::move(key_value_pair));
         ETL_INCREMENT_DEBUG_COUNT;
 
           // Just add the pointer to the bucket;
-          bucket.insert_after(bucket.before_begin(), node);
+          bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(pbucket);
 
         result = iterator((pbuckets + number_of_buckets), pbucket, pbucket->begin());
@@ -776,13 +776,13 @@ namespace etl
         }
 
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key_value_pair) value_type(etl::move(key_value_pair));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key_value_pair) value_type(etl::move(key_value_pair));
         ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
         adjust_first_last_markers_after_insert(&bucket);
         ++inode_previous;
 
@@ -1274,14 +1274,14 @@ namespace etl
     //*************************************************************************
     /// Move from a range
     //*************************************************************************
-    void move(iterator first, iterator last)
+    void move(iterator b, iterator e)
     {
-      while (first != last)
+      while (b != e)
       {
-        iterator temp = first;
+        iterator temp = b;
         ++temp;
-        insert(etl::move(*first));
-        first = temp;
+        insert(etl::move(*b));
+        b = temp;
       }
     }
 #endif
@@ -1291,10 +1291,10 @@ namespace etl
     //*************************************************************************
     /// Create a node.
     //*************************************************************************
-    node_t& allocate_data_node()
+    node_t* allocate_data_node()
     {
       node_t* (etl::ipool::*func)() = &etl::ipool::allocate<node_t>;
-      return *(pnodepool->*func)();
+      return (pnodepool->*func)();
     }
 
     //*********************************************************************
@@ -1323,7 +1323,7 @@ namespace etl
     //*********************************************************************
     /// Adjust the first and last markers according to the erased entry.
     //*********************************************************************
-    void adjust_first_last_markers_after_erase(bucket_t* pcurrent)
+    void adjust_first_last_markers_after_erase(bucket_t* pbucket)
     {
       if (empty())
       {
@@ -1332,7 +1332,7 @@ namespace etl
       }
       else
       {
-        if (pcurrent == first)
+        if (pbucket == first)
         {
           // We erased the first so, we need to search again from where we erased.
           while (first->empty())
@@ -1340,29 +1340,29 @@ namespace etl
             ++first;
           }
         }
-        else if (pcurrent == last)
+        else if (pbucket == last)
         {
           // We erased the last, so we need to search again. Start from the first, go no further than the current last.
-          bucket_t* pcurrent = first;
+          pbucket = first;
           bucket_t* pend = last;
 
           last = first;
 
-          while (pcurrent != pend)
+          while (pbucket != pend)
           {
-            if (!pcurrent->empty())
+            if (!pbucket->empty())
             {
-              last = pcurrent;
+              last = pbucket;
             }
 
-            ++pcurrent;
+            ++pbucket;
           }
         }
       }
     }
 
     //*********************************************************************
-    /// Delete a data noe at the specified location.
+    /// Delete a data node at the specified location.
     //*********************************************************************
     local_iterator delete_data_node(local_iterator iprevious, local_iterator icurrent, bucket_t& bucket)
     {
@@ -1423,20 +1423,48 @@ namespace etl
   ///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
   ///\ingroup unordered_multimap
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator ==(const etl::iunordered_multimap<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_multimap<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename T, typename THash, typename TKeyEqual>
+  bool operator ==(const etl::iunordered_multimap<TKey, T, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_multimap<TKey, T, THash, TKeyEqual>& rhs)
   {
     const bool sizes_match = (lhs.size() == rhs.size());
     bool elements_match = true;
 
+    typedef typename etl::iunordered_multimap<TKey, T, THash, TKeyEqual>::const_iterator itr_t;
+
     if (sizes_match)
     {
-      for (size_t i = 0; (i < lhs.bucket_count()) && elements_match; ++i)
+      itr_t l_begin = lhs.begin();
+      itr_t l_end   = lhs.end();
+
+      while ((l_begin != l_end) && elements_match)
       {
-        if (!etl::is_permutation(lhs.begin(i), lhs.end(i), rhs.begin(i)))
+        const TKey key     = l_begin->first;
+        const T    l_value = l_begin->second;
+
+        // See if the lhs keys exist in the rhs.
+        ETL_OR_STD::pair<itr_t, itr_t> l_range = lhs.equal_range(key);
+        ETL_OR_STD::pair<itr_t, itr_t> r_range = rhs.equal_range(key);
+
+        if (r_range.first != rhs.end())
+        {
+          bool distance_match = (etl::distance(l_range.first, l_range.second) == etl::distance(r_range.first, r_range.second));
+
+          if (distance_match)
+          {
+            elements_match = etl::is_permutation(l_range.first, l_range.second, r_range.first, r_range.second);
+          }
+          else
+          {
+            elements_match = false;
+          }
+        }
+        else
         {
           elements_match = false;
         }
+
+        ++l_begin;
       }
     }
 
@@ -1450,8 +1478,9 @@ namespace etl
   ///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
   ///\ingroup unordered_multimap
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator !=(const etl::iunordered_multimap<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_multimap<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename T, typename THash, typename TKeyEqual>
+  bool operator !=(const etl::iunordered_multimap<TKey, T, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_multimap<TKey, T, THash, TKeyEqual>& rhs)
   {
     return !(lhs == rhs);
   }
diff --git a/include/etl/unordered_multiset.h b/include/etl/unordered_multiset.h
index be1acee7..a24eb3ff 100644
--- a/include/etl/unordered_multiset.h
+++ b/include/etl/unordered_multiset.h
@@ -664,13 +664,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(key);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(key);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(&bucket);
 
         result.first = iterator((pbuckets + number_of_buckets), pbucket, pbucket->begin());
@@ -695,13 +695,13 @@ namespace etl
         }
 
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(key);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(key);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Add the node to the end of the bucket;
-        bucket.insert_after(inode_previous, node);
+        bucket.insert_after(inode_previous, *node);
         adjust_first_last_markers_after_insert(&bucket);
         ++inode_previous;
 
@@ -735,13 +735,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(etl::move(key));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(etl::move(key));
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(&bucket);
 
         result.first = iterator((pbuckets + number_of_buckets), pbucket, pbucket->begin());
@@ -766,13 +766,13 @@ namespace etl
         }
 
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(etl::move(key));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(etl::move(key));
         ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
         adjust_first_last_markers_after_insert(&bucket);
         ++inode_previous;
 
@@ -1252,14 +1252,14 @@ namespace etl
     //*************************************************************************
     /// Move from a range
     //*************************************************************************
-    void move(iterator first, iterator last)
+    void move(iterator b, iterator e)
     {
-      while (first != last)
+      while (b != e)
       {
-        iterator temp = first;
+        iterator temp = b;
         ++temp;
-        insert(etl::move(*first));
-        first = temp;
+        insert(etl::move(*b));
+        b = temp;
       }
     }
 #endif
@@ -1269,10 +1269,10 @@ namespace etl
     //*************************************************************************
     /// Create a node.
     //*************************************************************************
-    node_t& allocate_data_node()
+    node_t* allocate_data_node()
     {
       node_t* (etl::ipool::*func)() = &etl::ipool::allocate<node_t>;
-      return *(pnodepool->*func)();
+      return (pnodepool->*func)();
     }
 
     //*********************************************************************
@@ -1301,7 +1301,7 @@ namespace etl
     //*********************************************************************
     /// Adjust the first and last markers according to the erased entry.
     //*********************************************************************
-    void adjust_first_last_markers_after_erase(bucket_t* pcurrent)
+    void adjust_first_last_markers_after_erase(bucket_t* pbucket)
     {
       if (empty())
       {
@@ -1310,7 +1310,7 @@ namespace etl
       }
       else
       {
-        if (pcurrent == first)
+        if (pbucket == first)
         {
           // We erased the first so, we need to search again from where we erased.
           while (first->empty())
@@ -1318,29 +1318,29 @@ namespace etl
             ++first;
           }
         }
-        else if (pcurrent == last)
+        else if (pbucket == last)
         {
           // We erased the last, so we need to search again. Start from the first, go no further than the current last.
-          bucket_t* pcurrent = first;
+          pbucket = first;
           bucket_t* pend = last;
 
           last = first;
 
-          while (pcurrent != pend)
+          while (pbucket != pend)
           {
-            if (!pcurrent->empty())
+            if (!pbucket->empty())
             {
-              last = pcurrent;
+              last = pbucket;
             }
 
-            ++pcurrent;
+            ++pbucket;
           }
         }
       }
     }
 
     //*********************************************************************
-    /// Delete a data noe at the specified location.
+    /// Delete a data node at the specified location.
     //*********************************************************************
     local_iterator delete_data_node(local_iterator iprevious, local_iterator icurrent, bucket_t& bucket)
     {
@@ -1401,20 +1401,47 @@ namespace etl
   ///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
   ///\ingroup unordered_multiset
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator ==(const etl::iunordered_multiset<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_multiset<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename THash, typename TKeyEqual>
+  bool operator ==(const etl::iunordered_multiset<TKey, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_multiset<TKey, THash, TKeyEqual>& rhs)
   {
     const bool sizes_match = (lhs.size() == rhs.size());
     bool elements_match = true;
 
+    typedef typename etl::iunordered_multiset<TKey, THash, TKeyEqual>::const_iterator itr_t;
+
     if (sizes_match)
     {
-      for (size_t i = 0; (i < lhs.bucket_count()) && elements_match; ++i)
+      itr_t l_begin = lhs.begin();
+      itr_t l_end   = lhs.end();
+
+      while ((l_begin != l_end) && elements_match)
       {
-        if (!etl::is_permutation(lhs.begin(i), lhs.end(i), rhs.begin(i)))
+        const TKey l_value = *l_begin;
+
+        // See if the lhs keys exist in the rhs.
+        ETL_OR_STD::pair<itr_t, itr_t> l_range = lhs.equal_range(l_value);
+        ETL_OR_STD::pair<itr_t, itr_t> r_range = rhs.equal_range(l_value);
+
+        if (r_range.first != rhs.end())
+        {
+          bool distance_match = (etl::distance(l_range.first, l_range.second) == etl::distance(r_range.first, r_range.second));
+
+          if (distance_match)
+          {
+            elements_match = etl::is_permutation(l_range.first, l_range.second, r_range.first, r_range.second);
+          }
+          else
+          {
+            elements_match = false;
+          }
+        }
+        else
         {
           elements_match = false;
         }
+
+        ++l_begin;
       }
     }
 
@@ -1428,8 +1455,9 @@ namespace etl
   ///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
   ///\ingroup unordered_multiset
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator !=(const etl::iunordered_multiset<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_multiset<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename THash, typename TKeyEqual>
+  bool operator !=(const etl::iunordered_multiset<TKey, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_multiset<TKey, THash, TKeyEqual>& rhs)
   {
     return !(lhs == rhs);
   }
diff --git a/include/etl/unordered_set.h b/include/etl/unordered_set.h
index 35dce097..28e6360d 100644
--- a/include/etl/unordered_set.h
+++ b/include/etl/unordered_set.h
@@ -678,13 +678,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(key);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(key);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(&bucket);
 
         result.first = iterator(pbuckets + number_of_buckets, pbucket, pbucket->begin());
@@ -712,13 +712,13 @@ namespace etl
         if (inode == bucket.end())
         {
           // Get a new node.
-          node_t& node = allocate_data_node();
-          node.clear();
-          ::new (&node.key) value_type(key);
+          node_t* node = allocate_data_node();
+          node->clear();
+          ::new (&node->key) value_type(key);
           ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
           adjust_first_last_markers_after_insert(&bucket);
           ++inode_previous;
 
@@ -766,13 +766,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(etl::move(key));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(etl::move(key));
         ETL_INCREMENT_DEBUG_COUNT;
 
           // Just add the pointer to the bucket;
-          bucket.insert_after(bucket.before_begin(), node);
+          bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(&bucket);
 
         result.first = iterator(pbuckets + number_of_buckets, pbucket, pbucket->begin());
@@ -800,13 +800,13 @@ namespace etl
         if (inode == bucket.end())
         {
           // Get a new node.
-          node_t& node = allocate_data_node();
-          node.clear();
-          ::new (&node.key) value_type(etl::move(key));
+          node_t* node = allocate_data_node();
+          node->clear();
+          ::new (&node->key) value_type(etl::move(key));
           ETL_INCREMENT_DEBUG_COUNT;
 
             // Add the node to the end of the bucket;
-            bucket.insert_after(inode_previous, node);
+            bucket.insert_after(inode_previous, *node);
           adjust_first_last_markers_after_insert(&bucket);
           ++inode_previous;
 
@@ -1272,20 +1272,20 @@ namespace etl
     //*************************************************************************
     /// Move from a range
     //*************************************************************************
-    void move(iterator first, iterator last)
+    void move(iterator b, iterator e)
     {
 #if ETL_IS_DEBUG_BUILD
-      difference_type d = etl::distance(first, last);
+      difference_type d = etl::distance(b, e);
       ETL_ASSERT(d >= 0, ETL_ERROR(unordered_set_iterator));
       ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_set_full));
 #endif
 
-      while (first != last)
+      while (b != e)
       {
-        iterator temp = first;
+        iterator temp = b;
         ++temp;
-        insert(etl::move(*first));
-        first = temp;
+        insert(etl::move(*b));
+        b = temp;
       }
     }
 #endif
@@ -1295,10 +1295,10 @@ namespace etl
     //*************************************************************************
     /// Create a node.
     //*************************************************************************
-    node_t& allocate_data_node()
+    node_t* allocate_data_node()
     {
       node_t* (etl::ipool::*func)() = &etl::ipool::allocate<node_t>;
-      return *(pnodepool->*func)();
+      return (pnodepool->*func)();
     }
 
     //*********************************************************************
@@ -1309,7 +1309,7 @@ namespace etl
       if (size() == 1)
       {
         first = pbucket;
-        last = pbucket;
+        last  = pbucket;
       }
       else
       {
@@ -1327,7 +1327,7 @@ namespace etl
     //*********************************************************************
     /// Adjust the first and last markers according to the erased entry.
     //*********************************************************************
-    void adjust_first_last_markers_after_erase(bucket_t* pcurrent)
+    void adjust_first_last_markers_after_erase(bucket_t* pbucket)
     {
       if (empty())
       {
@@ -1336,7 +1336,7 @@ namespace etl
       }
       else
       {
-        if (pcurrent == first)
+        if (pbucket == first)
         {
           // We erased the first so, we need to search again from where we erased.
           while (first->empty())
@@ -1344,29 +1344,29 @@ namespace etl
             ++first;
           }
         }
-        else if (pcurrent == last)
+        else if (pbucket == last)
         {
           // We erased the last, so we need to search again. Start from the first, go no further than the current last.
-          bucket_t* pcurrent = first;
+          pbucket = first;
           bucket_t* pend = last;
 
           last = first;
 
-          while (pcurrent != pend)
+          while (pbucket != pend)
           {
-            if (!pcurrent->empty())
+            if (!pbucket->empty())
             {
-              last = pcurrent;
+              last = pbucket;
             }
 
-            ++pcurrent;
+            ++pbucket;
           }
         }
       }
     }
 
     //*********************************************************************
-    /// Delete a data noe at the specified location.
+    /// Delete a data node at the specified location.
     //*********************************************************************
     local_iterator delete_data_node(local_iterator iprevious, local_iterator icurrent, bucket_t& bucket)
     {
@@ -1427,20 +1427,40 @@ namespace etl
   ///\return <b>true</b> if the sets are equal, otherwise <b>false</b>
   ///\ingroup unordered_set
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator ==(const etl::iunordered_set<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_set<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename THash, typename TKeyEqual>
+  bool operator ==(const etl::iunordered_set<TKey, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_set<TKey, THash, TKeyEqual>& rhs)
   {
     const bool sizes_match = (lhs.size() == rhs.size());
     bool elements_match = true;
 
+    typedef typename etl::iunordered_set<TKey, THash, TKeyEqual>::const_iterator itr_t;
+
     if (sizes_match)
     {
-      for (size_t i = 0; (i < lhs.bucket_count()) && elements_match; ++i)
+      itr_t l_begin = lhs.begin();
+      itr_t l_end   = lhs.end();
+
+      while ((l_begin != l_end) && elements_match)
       {
-        if (!etl::is_permutation(lhs.begin(i), lhs.end(i), rhs.begin(i)))
+        const TKey l_value = *l_begin;
+
+        // See if the lhs key exists in the rhs.
+        ETL_OR_STD::pair<itr_t, itr_t> range = rhs.equal_range(l_value);
+
+        if (range.first != rhs.end())
+        {
+          // See if the values match
+          const TKey r_value = *(range.first);
+
+          elements_match = (r_value == l_value);
+        }
+        else
         {
           elements_match = false;
         }
+
+        ++l_begin;
       }
     }
 
@@ -1454,8 +1474,9 @@ namespace etl
   ///\return <b>true</b> if the sets are not equal, otherwise <b>false</b>
   ///\ingroup unordered_set
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator !=(const etl::iunordered_set<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_set<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename THash, typename TKeyEqual>
+  bool operator !=(const etl::iunordered_set<TKey, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_set<TKey, THash, TKeyEqual>& rhs)
   {
     return !(lhs == rhs);
   }
diff --git a/include/etl/vector.h b/include/etl/vector.h
index af236dc7..4150c443 100644
--- a/include/etl/vector.h
+++ b/include/etl/vector.h
@@ -1346,11 +1346,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-    virtual
-#endif
+    virtual void repair() ETL_OVERRIDE
+#else
     void repair()
-#ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
 #endif
     {
       ETL_ASSERT_OR_RETURN(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::vector_incompatible_type));
@@ -1527,9 +1525,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
@@ -1649,9 +1648,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::ivector<T*>::repair_buffer(buffer);
@@ -1806,9 +1806,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::ivector<T*>::repair_buffer(this->p_buffer);
diff --git a/include/etl/wstring.h b/include/etl/wstring.h
index 20ce4ac4..683359de 100644
--- a/include/etl/wstring.h
+++ b/include/etl/wstring.h
@@ -231,9 +231,10 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #if ETL_HAS_ISTRING_REPAIR
-    virtual
-#endif
+    virtual void repair() ETL_OVERRIDE
+#else
     void repair()
+#endif
     {
       etl::iwstring::repair_buffer(buffer);
     }
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/support/Release notes.txt b/support/Release notes.txt
index e5ebacf8..82f4905d 100644
--- a/support/Release notes.txt	
+++ b/support/Release notes.txt	
@@ -1,5 +1,6 @@
 ===============================================================================
 20.38.11
+#812-Implement-SAE-J1850-CRC8
 #850 Fixed names according to Arduino's guidelines
 
 ===============================================================================
@@ -160,7 +161,7 @@ Comments and noexcept updates to placement new
 etl::variant (variadic) refactor and updates for C++ standards compatibility
 etl::overload available in C++17 only
 map/flat_map speed optimisations
-Various C++03 compatibilty updates for maps
+Various C++03 compatibility updates for maps
 Refactored Bash compilation scripts to allow selection of C++ standard and optimisation level
 Renamed Bash compilation scripts. Changed 'sanity checks' to 'syntax checks
 Some internal constant case changes from all upper to capital case
@@ -226,7 +227,7 @@ Removed unused ETL_USE_MEM_BUILTINS option
 
 ===============================================================================
 20.35.7
-Updated etl::delgate to handle const functors correctly
+Updated etl::delegate to handle const functors correctly
 
 ===============================================================================
 20.35.6
@@ -274,7 +275,7 @@ Removed duplicate include in etl::array_view
 #621 No need to initialize the C-compiler, small speed improvement
 #626 Empty etl::optional ctor storage initialization performance
 Removed constexpr for etl::bit_cast due to unreliability of compiler support
-Added has_value() as an alias for is_value() for etl::result (consistancy with STL conventions)
+Added has_value() as an alias for is_value() for etl::result (consistency with STL conventions)
 Added ETL_ERROR_WITH_VALUE macro for exceptions that require a value
 Changed scaling template parameter for etl::scaled_rounding to uint32_t
 Remove redundant etl::pair functions
@@ -471,7 +472,7 @@ Fixed send_message function signatures.
 20.24.0
 #503 Algorithm transform uses expensive post increment operator - Fixed for all occurrences of iterator increment.
 #504 ETL_CONSTANT vs const in binary.h - Fixed.
-Many algorithms will leverage built-ins, if available. Dependant on compiler version.
+Many algorithms will leverage built-ins, if available. Dependent on compiler version.
 Added detection or selection of built-ins.
 Much of etl::string and etl::string_view can be constexpr.
 Added ETL initializer_list implementations that are compatible with major compilers.
@@ -839,7 +840,7 @@ Added example application for shared messages.
 Added a lockable queue with locks implemented as pure virtuals.
 Refactored the other queues.
 Fixed missing virtual destructor for C++11 observer.
-Added etl::successor class for consistant 'chain of responsibilty' pattern generation.
+Added etl::successor class for consistent 'chain of responsibilty' pattern generation.
 Added missing constructors to unique_ptr.
 Added nullptr check to unique_ptr destructor.
 Fixed VS2019 warning for etl::deque iterators.
@@ -1807,7 +1808,7 @@ Added constexpr constructors to string_view and array_view.
 
 ===============================================================================
 14.8.2
-Added missing #include "stl/interator.h" in frame_check_sequence.h
+Added missing #include "stl/iterator.h" in frame_check_sequence.h
 
 ===============================================================================
 14.8.1
@@ -2040,7 +2041,7 @@ Added SPSC & MPPC queues
 
 ===============================================================================
 11.3.0
-Improved compatibility with 64 bit pltforms.
+Improved compatibility with 64 bit platforms.
 
 ===============================================================================
 11.2.0
@@ -2077,7 +2078,7 @@ Improved etl::endianness. Added static functions.
 
 ===============================================================================
 10.19.2
-Fixed strict aliasing warnings for endianess.
+Fixed strict aliasing warnings for endianness.
 
 ===============================================================================
 10.19.1
@@ -2086,7 +2087,7 @@ Fixed strict aliasing warnings for aligned storage.
 ===============================================================================
 10.19.0
 Added 'create' and 'destroy' functions to pools.
-Modified class heirarchy.
+Modified class hierarchy.
 etl::generic_pool is derived from on etl::ipool.
 etl::pool is derived from etl::generic_pool.
 
diff --git a/support/avr-stl-1.1.1.zip b/support/avr-stl-1.1.1.zip
deleted file mode 100644
index 335f511a..00000000
Binary files a/support/avr-stl-1.1.1.zip and /dev/null differ
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 4869a7c8..eaf80ec1 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -98,6 +98,8 @@ add_executable(etl_tests
 	test_crc8_ebu.cpp
 	test_crc8_icode.cpp
 	test_crc8_itu.cpp
+	test_crc8_j1850_zero.cpp
+	test_crc8_j1850.cpp
 	test_crc8_maxim.cpp
 	test_crc8_rohc.cpp
 	test_crc8_wcdma.cpp
@@ -381,6 +383,8 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 			-Werror
 			-Wfloat-equal
 			-Wuseless-cast
+			-Wshadow
+			-Wnull-dereference
 			)
 endif ()
 
@@ -393,11 +397,13 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 			-Wextra
 			-Werror
 			-Wfloat-equal
+			-Wshadow
+			-Wnull-dereference
 			)
 endif ()
 
 if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-	if (ETL_ENABLE_SANITIZER)
+	if (ETL_ENABLE_SANITIZER MATCHES "ON")
 		message(STATUS "Compiling with Sanitizer enabled")
 		# MinGW doesn't presently support sanitization
 		if (NOT MINGW)
diff --git a/test/UnitTest++/CheckMacros.h b/test/UnitTest++/CheckMacros.h
index 4cb5767c..f655d884 100644
--- a/test/UnitTest++/CheckMacros.h
+++ b/test/UnitTest++/CheckMacros.h
@@ -19,10 +19,10 @@
          UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), #value); \
    })                                                                                                                                 \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                       \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                       \
    {                                                                                                                                  \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                     \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK(" #value ")";                                            \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK(" #value ")";                                            \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),             \
                                                       UnitTest_message.GetText());                                                    \
    })                                                                                                                                 \
@@ -41,10 +41,10 @@
          UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), #value); \
    })                                                                                                                                 \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                       \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                       \
    {                                                                                                                                  \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                     \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK(" #value ")";                                            \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK(" #value ")";                                            \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),             \
                                                       UnitTest_message.GetText());                                                    \
    })                                                                                                                                 \
@@ -62,10 +62,10 @@
       UnitTest::CheckEqual(*UnitTest::CurrentTest::Results(), expected, actual, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                      \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                                      \
    {                                                                                                                                                 \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                                    \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                     \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                     \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                            \
                                                       UnitTest_message.GetText());                                                                   \
    })                                                                                                                                                \
@@ -83,10 +83,10 @@
       UnitTest::CheckEqualHex(*UnitTest::CurrentTest::Results(), expected, actual, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                      \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                                      \
    {                                                                                                                                                 \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                                    \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                     \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                     \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                            \
                                                       UnitTest_message.GetText());                                                                   \
    })                                                                                                                                                \
@@ -104,10 +104,10 @@
       UnitTest::CheckNotEqual(*UnitTest::CurrentTest::Results(), expected, actual, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                      \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                                      \
    {                                                                                                                                                 \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                                    \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                     \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                     \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                            \
                                                       UnitTest_message.GetText());                                                                   \
    })                                                                                                                                                \
@@ -125,10 +125,10 @@
       UnitTest::CheckNotEqualHex(*UnitTest::CurrentTest::Results(), expected, actual, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                      \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                                      \
    {                                                                                                                                                 \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                                    \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                     \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                     \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                            \
                                                       UnitTest_message.GetText());                                                                   \
    })                                                                                                                                                \
@@ -146,10 +146,10 @@
       UnitTest::CheckClose(*UnitTest::CurrentTest::Results(), expected, actual, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                           \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                                 \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                                                 \
    {                                                                                                                                                            \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                                               \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_CLOSE(" #expected ", " #actual ")";                                                \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK_CLOSE(" #expected ", " #actual ")";                                                \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                       \
                                                       UnitTest_message.GetText());                                                                              \
    })                                                                                                                                                           \
@@ -167,10 +167,10 @@
       UnitTest::CheckArrayEqual(*UnitTest::CurrentTest::Results(), expected, actual, count, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                            \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                                  \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                                                  \
    {                                                                                                                                                             \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                                                \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_EQUAL(" #expected ", " #actual ")";                                           \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK_ARRAY_EQUAL(" #expected ", " #actual ")";                                           \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                        \
                                                       UnitTest_message.GetText());                                                                               \
    })                                                                                                                                                            \
@@ -188,10 +188,10 @@
       UnitTest::CheckArrayClose(*UnitTest::CurrentTest::Results(), expected, actual, count, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                                       \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                                             \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                                                             \
    {                                                                                                                                                                        \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                                                           \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_CLOSE(" #expected ", " #actual ")";                                                      \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK_ARRAY_CLOSE(" #expected ", " #actual ")";                                                      \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                                   \
                                                       UnitTest_message.GetText());                                                                                          \
    })                                                                                                                                                                       \
@@ -209,10 +209,10 @@
       UnitTest::CheckArray2DClose(*UnitTest::CurrentTest::Results(), expected, actual, rows, columns, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                                                 \
    UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                                                       \
+   UNITTEST_IMPL_CATCH (std::exception, exc,                                                                                                                                                       \
    {                                                                                                                                                                                  \
       UnitTest::MemoryOutStream UnitTest_message;                                                                                                                                     \
-      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY2D_CLOSE(" #expected ", " #actual ")";                                                              \
+      UnitTest_message << "Unhandled exception (" << exc.what() << ") in CHECK_ARRAY2D_CLOSE(" #expected ", " #actual ")";                                                              \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                                             \
                                                       UnitTest_message.GetText());                                                                                                    \
    })                                                                                                                                                                                 \
diff --git a/test/UnitTest++/Checks.h b/test/UnitTest++/Checks.h
index a2571e02..501ab7ff 100644
--- a/test/UnitTest++/Checks.h
+++ b/test/UnitTest++/Checks.h
@@ -34,7 +34,7 @@ namespace UnitTest
   template <>
   inline std::string DisplayValue(const char& c)
   {
-    using type = std::char_traits<char>::int_type;
+    typedef std::char_traits<char>::int_type type;
 
     std::ostringstream oss;
 
@@ -47,7 +47,7 @@ namespace UnitTest
   template <>
   inline std::string DisplayValue(const char8_t& c)
   {
-    using type = std::char_traits<char8_t>::int_type;
+    typedef std::char_traits<char8_t>::int_type type;
 
     std::ostringstream oss;
 
@@ -60,7 +60,7 @@ namespace UnitTest
   template <>
   inline std::string DisplayValue(const wchar_t& c)
   {
-    using type = std::char_traits<wchar_t>::int_type;
+    typedef std::char_traits<wchar_t>::int_type type;
 
     std::ostringstream oss;
 
@@ -73,7 +73,7 @@ namespace UnitTest
   template <>
   inline std::string DisplayValue(const char16_t& c)
   {
-    using type = std::char_traits<char16_t>::int_type;
+    typedef std::char_traits<char16_t>::int_type type;
 
     std::ostringstream oss;
 
@@ -85,7 +85,7 @@ namespace UnitTest
   template <>
   inline std::string DisplayValue(const char32_t& c)
   {
-    using type = std::char_traits<char32_t>::int_type;
+    typedef std::char_traits<char32_t>::int_type type;
 
     std::ostringstream oss;
 
@@ -171,6 +171,7 @@ namespace UnitTest
      return !value;
    }
 
+#if __cplusplus >= 201103L
    template< typename Expected, typename Actual >
    void CheckEqual(TestResults& results, Expected&& expected, Actual&& actual, TestDetails const& details)
    {
@@ -183,6 +184,20 @@ namespace UnitTest
        results.OnTestFailure(details, stream.GetText());
      }
    }
+#else
+   template< typename Expected, typename Actual >
+   void CheckEqual(TestResults& results, Expected const& expected, Actual const& actual, TestDetails const& details)
+   {
+     if (!(expected == actual))
+     {
+       UnitTest::MemoryOutStream stream;
+       stream << "Expected "
+         << DisplayValue(expected) << " but was " << DisplayValue(actual);
+
+       results.OnTestFailure(details, stream.GetText());
+     }
+   }
+#endif
 
    template< typename Expected, typename Actual >
    void CheckEqualHex(TestResults& results, Expected const& expected, Actual const& actual, TestDetails const& details)
@@ -190,7 +205,9 @@ namespace UnitTest
      if (!(expected == actual))
      {
        UnitTest::MemoryOutStream stream;
-       stream << std::hex << std::uppercase << std::setfill('0') << "Expected 0x" << std::setw(2 * sizeof(Expected)) << expected << " but was 0x" << std::setw(2 * sizeof(Actual)) << actual;
+       stream << std::hex << std::uppercase << std::setfill('0') 
+              << "Expected 0x" << std::setw(2 * sizeof(Expected)) << (expected & ~(typename std::make_unsigned<Expected>::type(0))) 
+              << " but was 0x" << std::setw(2 * sizeof(Actual))   << (actual   & ~(typename std::make_unsigned<Actual>::type(0)));
 
        results.OnTestFailure(details, stream.GetText());
      }
@@ -214,7 +231,8 @@ namespace UnitTest
      if (expected == actual)
      {
        UnitTest::MemoryOutStream stream;
-       stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2 * sizeof(Actual)) << "Expected not equal, but both values are " << actual;
+       stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2 * sizeof(Actual)) 
+              << "Expected not equal, but both values are " << (actual & ~(typename std::make_unsigned<Actual>::type(0)));
 
        results.OnTestFailure(details, stream.GetText());
      }
diff --git a/test/UnitTest++/ExecuteTest.h b/test/UnitTest++/ExecuteTest.h
index 2759aad9..d632d4cd 100644
--- a/test/UnitTest++/ExecuteTest.h
+++ b/test/UnitTest++/ExecuteTest.h
@@ -39,12 +39,12 @@ namespace UnitTest {
          testObject.RunImpl();
       })
 #endif
-      UNITTEST_IMPL_CATCH(RequiredCheckException, e, { (void)e; })
-      UNITTEST_IMPL_CATCH(AssertException, e, { (void)e; })
-      UNITTEST_IMPL_CATCH(std::exception, e,
+      UNITTEST_IMPL_CATCH(RequiredCheckException, exc, { (void)exc; })
+      UNITTEST_IMPL_CATCH(AssertException, exc, { (void)exc; })
+      UNITTEST_IMPL_CATCH(std::exception, exc,
       {
          MemoryOutStream stream;
-         stream << "Unhandled exception: " << e.what();
+         stream << "Unhandled exception: " << exc.what();
          CurrentTest::Results()->OnTestFailure(details, stream.GetText());
       })
       UNITTEST_IMPL_CATCH_ALL
diff --git a/test/etl_error_handler/exceptions/CMakeLists.txt b/test/etl_error_handler/exceptions/CMakeLists.txt
index 3eb91a71..fcbbdc48 100644
--- a/test/etl_error_handler/exceptions/CMakeLists.txt
+++ b/test/etl_error_handler/exceptions/CMakeLists.txt
@@ -54,21 +54,61 @@ target_include_directories(etl_tests
   ${CMAKE_CURRENT_LIST_DIR}
   )
 
-if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+	message(STATUS "Using GCC compiler")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    message(STATUS "Using Clang compiler")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 	target_compile_options(etl_tests
 			PRIVATE
-			-fsanitize=address,undefined,bounds
 			-fno-omit-frame-pointer
+			-fno-common
 			-Wall
 			-Wextra
-			-Werror 
+			-Werror
+			-Wfloat-equal
+			-Wuseless-cast
+			-Wshadow
+			-Wnull-dereference
 			)
-	target_link_options(etl_tests
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	target_compile_options(etl_tests
 			PRIVATE
-			-fsanitize=address,undefined,bounds
+			-fno-omit-frame-pointer
+			-fno-common
+			-Wall
+			-Wextra
+			-Werror
+			-Wfloat-equal
+			-Wshadow
+			-Wnull-dereference
 			)
 endif ()
 
+if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+	if (ETL_ENABLE_SANITIZER MATCHES "ON")
+		message(STATUS "Compiling with Sanitizer enabled")
+		# MinGW doesn't presently support sanitization
+		if (NOT MINGW)
+			target_compile_options(etl_tests
+				PRIVATE
+				-fsanitize=address,undefined,bounds
+				)
+
+			target_link_options(etl_tests
+				PRIVATE
+				-fsanitize=address,undefined,bounds
+				)	
+		endif()
+	endif ()
+endif ()
+
 # Enable the 'make test' CMake target using the executable defined above
 add_test(etl_error_handler_unit_tests etl_tests)
 
diff --git a/test/etl_error_handler/log_errors/CMakeLists.txt b/test/etl_error_handler/log_errors/CMakeLists.txt
index cbea8e44..4019cf25 100644
--- a/test/etl_error_handler/log_errors/CMakeLists.txt
+++ b/test/etl_error_handler/log_errors/CMakeLists.txt
@@ -54,21 +54,61 @@ target_include_directories(etl_tests
   ${CMAKE_CURRENT_LIST_DIR}
   )
 
-if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+	message(STATUS "Using GCC compiler")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    message(STATUS "Using Clang compiler")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 	target_compile_options(etl_tests
 			PRIVATE
-			-fsanitize=address,undefined,bounds
 			-fno-omit-frame-pointer
+			-fno-common
 			-Wall
 			-Wextra
 			-Werror
+			-Wfloat-equal
+			-Wuseless-cast
+			-Wshadow
+			-Wnull-dereference
 			)
-	target_link_options(etl_tests
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	target_compile_options(etl_tests
 			PRIVATE
-			-fsanitize=address,undefined,bounds
+			-fno-omit-frame-pointer
+			-fno-common
+			-Wall
+			-Wextra
+			-Werror
+			-Wfloat-equal
+			-Wshadow
+			-Wnull-dereference
 			)
 endif ()
 
+if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+	if (ETL_ENABLE_SANITIZER MATCHES "ON")
+		message(STATUS "Compiling with Sanitizer enabled")
+		# MinGW doesn't presently support sanitization
+		if (NOT MINGW)
+			target_compile_options(etl_tests
+				PRIVATE
+				-fsanitize=address,undefined,bounds
+				)
+
+			target_link_options(etl_tests
+				PRIVATE
+				-fsanitize=address,undefined,bounds
+				)	
+		endif()
+	endif ()
+endif ()
+
 # Enable the 'make test' CMake target using the executable defined above
 add_test(etl_error_handler_unit_tests etl_tests)
 
diff --git a/test/etl_error_handler/log_errors_and_exceptions/CMakeLists.txt b/test/etl_error_handler/log_errors_and_exceptions/CMakeLists.txt
index 6ef1fa64..a043c9c2 100644
--- a/test/etl_error_handler/log_errors_and_exceptions/CMakeLists.txt
+++ b/test/etl_error_handler/log_errors_and_exceptions/CMakeLists.txt
@@ -55,21 +55,61 @@ target_include_directories(etl_tests
   ${CMAKE_CURRENT_LIST_DIR}
   )
 
-if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+	message(STATUS "Using GCC compiler")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    message(STATUS "Using Clang compiler")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 	target_compile_options(etl_tests
 			PRIVATE
-			-fsanitize=address,undefined,bounds
 			-fno-omit-frame-pointer
+			-fno-common
 			-Wall
 			-Wextra
 			-Werror
+			-Wfloat-equal
+			-Wuseless-cast
+			-Wshadow
+			-Wnull-dereference
 			)
-	target_link_options(etl_tests
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	target_compile_options(etl_tests
 			PRIVATE
-			-fsanitize=address,undefined,bounds
+			-fno-omit-frame-pointer
+			-fno-common
+			-Wall
+			-Wextra
+			-Werror
+			-Wfloat-equal
+			-Wshadow
+			-Wnull-dereference
 			)
 endif ()
 
+if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+	if (ETL_ENABLE_SANITIZER MATCHES "ON")
+		message(STATUS "Compiling with Sanitizer enabled")
+		# MinGW doesn't presently support sanitization
+		if (NOT MINGW)
+			target_compile_options(etl_tests
+				PRIVATE
+				-fsanitize=address,undefined,bounds
+				)
+
+			target_link_options(etl_tests
+				PRIVATE
+				-fsanitize=address,undefined,bounds
+				)	
+		endif()
+	endif ()
+endif ()
+
 # Enable the 'make test' CMake target using the executable defined above
 add_test(etl_error_handler_unit_tests etl_tests)
 
diff --git a/test/etl_initializer_list/CMakeLists.txt b/test/etl_initializer_list/CMakeLists.txt
index 132fb00f..647b590a 100644
--- a/test/etl_initializer_list/CMakeLists.txt
+++ b/test/etl_initializer_list/CMakeLists.txt
@@ -55,21 +55,61 @@ target_include_directories(etl_tests
   ${CMAKE_CURRENT_LIST_DIR}
   )
 
-if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+	message(STATUS "Using GCC compiler")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    message(STATUS "Using Clang compiler")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 	target_compile_options(etl_tests
 			PRIVATE
-			-fsanitize=address,undefined,bounds
 			-fno-omit-frame-pointer
+			-fno-common
 			-Wall
 			-Wextra
 			-Werror
+			-Wfloat-equal
+			-Wuseless-cast
+			-Wshadow
+			-Wnull-dereference
 			)
-	target_link_options(etl_tests
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	target_compile_options(etl_tests
 			PRIVATE
-			-fsanitize=address,undefined,bounds
+			-fno-omit-frame-pointer
+			-fno-common
+			-Wall
+			-Wextra
+			-Werror
+			-Wfloat-equal
+			-Wshadow
+			-Wnull-dereference
 			)
 endif ()
 
+if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+	if (ETL_ENABLE_SANITIZER MATCHES "ON")
+		message(STATUS "Compiling with Sanitizer enabled")
+		# MinGW doesn't presently support sanitization
+		if (NOT MINGW)
+			target_compile_options(etl_tests
+				PRIVATE
+				-fsanitize=address,undefined,bounds
+				)
+
+			target_link_options(etl_tests
+				PRIVATE
+				-fsanitize=address,undefined,bounds
+				)	
+		endif()
+	endif ()
+endif ()
+
 # Enable the 'make test' CMake target using the executable defined above
 add_test(etl_initializer_list_unit_tests etl_tests)
 
diff --git a/test/etl_initializer_list/etl_initializer_list.vcxproj b/test/etl_initializer_list/etl_initializer_list.vcxproj
index 61eaaf3c..c20c4ed5 100644
--- a/test/etl_initializer_list/etl_initializer_list.vcxproj
+++ b/test/etl_initializer_list/etl_initializer_list.vcxproj
@@ -40,26 +40,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
diff --git a/test/run-tests.sh b/test/run-tests.sh
index 92d80738..41fd6b29 100644
--- a/test/run-tests.sh
+++ b/test/run-tests.sh
@@ -283,7 +283,7 @@ compiler=$clang_compiler
 SetConfigurationName "STL"
 PrintHeader
 rm * -rf
-cmake -DCMAKE_C_COMPILER="gcc" -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
+cmake -DCMAKE_C_COMPILER="clang" -DCMAKE_CXX_COMPILER="clang++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
 cmake --build .
 if [ $? -eq 0 ]; then
   PassedCompilation
diff --git a/test/syntax_check/c++03/CMakeLists.txt b/test/syntax_check/c++03/CMakeLists.txt
index 0b63c6b2..7a425be1 100644
--- a/test/syntax_check/c++03/CMakeLists.txt
+++ b/test/syntax_check/c++03/CMakeLists.txt
@@ -38,6 +38,10 @@ set_target_properties(t98 PROPERTIES
         CXX_STANDARD_REQUIRED ON
         CXX_EXTENSIONS ON
         )
+target_compile_options(t98
+	    PRIVATE
+		-fsyntax-only
+		)
 target_sources(t98 PRIVATE etl_profile.h
         ../absolute.h.t.cpp
         ../algorithm.h.t.cpp
@@ -123,6 +127,8 @@ target_sources(t98 PRIVATE etl_profile.h
         ../crc8_maxim.h.t.cpp
         ../crc8_rohc.h.t.cpp
         ../crc8_wcdma.h.t.cpp
+        ../crc8_j1850.h.t.cpp
+        ../crc8_j1850_zero.h.t.cpp
         ../cyclic_value.h.t.cpp
         ../debounce.h.t.cpp
         ../debug_count.h.t.cpp
diff --git a/test/syntax_check/c++11/CMakeLists.txt b/test/syntax_check/c++11/CMakeLists.txt
index 72900939..29dc304e 100644
--- a/test/syntax_check/c++11/CMakeLists.txt
+++ b/test/syntax_check/c++11/CMakeLists.txt
@@ -38,6 +38,10 @@ set_target_properties(t11 PROPERTIES
         CXX_STANDARD_REQUIRED ON
         CXX_EXTENSIONS ON
         )
+target_compile_options(t11
+	    PRIVATE
+		-fsyntax-only
+		)
 target_sources(t11 PRIVATE etl_profile.h
         ../absolute.h.t.cpp
         ../algorithm.h.t.cpp
@@ -123,6 +127,8 @@ target_sources(t11 PRIVATE etl_profile.h
         ../crc8_maxim.h.t.cpp
         ../crc8_rohc.h.t.cpp
         ../crc8_wcdma.h.t.cpp
+        ../crc8_j1850.h.t.cpp
+        ../crc8_j1850_zero.h.t.cpp
         ../cyclic_value.h.t.cpp
         ../debounce.h.t.cpp
         ../debug_count.h.t.cpp
diff --git a/test/syntax_check/c++14/CMakeLists.txt b/test/syntax_check/c++14/CMakeLists.txt
index e9fb7a4e..9df6214c 100644
--- a/test/syntax_check/c++14/CMakeLists.txt
+++ b/test/syntax_check/c++14/CMakeLists.txt
@@ -38,6 +38,10 @@ set_target_properties(t14 PROPERTIES
         CXX_STANDARD_REQUIRED ON
         CXX_EXTENSIONS ON
         )
+target_compile_options(t14
+	    PRIVATE
+		-fsyntax-only
+		)
 target_sources(t14 PRIVATE etl_profile.h
         ../absolute.h.t.cpp
         ../algorithm.h.t.cpp
@@ -123,6 +127,8 @@ target_sources(t14 PRIVATE etl_profile.h
         ../crc8_maxim.h.t.cpp
         ../crc8_rohc.h.t.cpp
         ../crc8_wcdma.h.t.cpp
+        ../crc8_j1850.h.t.cpp
+        ../crc8_j1850_zero.h.t.cpp
         ../cyclic_value.h.t.cpp
         ../debounce.h.t.cpp
         ../debug_count.h.t.cpp
diff --git a/test/syntax_check/c++17/CMakeLists.txt b/test/syntax_check/c++17/CMakeLists.txt
index 4ab127ce..6be7bb03 100644
--- a/test/syntax_check/c++17/CMakeLists.txt
+++ b/test/syntax_check/c++17/CMakeLists.txt
@@ -38,6 +38,10 @@ set_target_properties(t17 PROPERTIES
         CXX_STANDARD_REQUIRED ON
         CXX_EXTENSIONS ON
         )
+target_compile_options(t17
+	    PRIVATE
+		-fsyntax-only
+		)
 target_sources(t17 PRIVATE etl_profile.h
         ../absolute.h.t.cpp
         ../algorithm.h.t.cpp
@@ -123,6 +127,8 @@ target_sources(t17 PRIVATE etl_profile.h
         ../crc8_maxim.h.t.cpp
         ../crc8_rohc.h.t.cpp
         ../crc8_wcdma.h.t.cpp
+        ../crc8_j1850.h.t.cpp
+        ../crc8_j1850_zero.h.t.cpp
         ../cyclic_value.h.t.cpp
         ../debounce.h.t.cpp
         ../debug_count.h.t.cpp
diff --git a/test/syntax_check/c++20/CMakeLists.txt b/test/syntax_check/c++20/CMakeLists.txt
index f5046f87..6c36b9d5 100644
--- a/test/syntax_check/c++20/CMakeLists.txt
+++ b/test/syntax_check/c++20/CMakeLists.txt
@@ -38,6 +38,10 @@ set_target_properties(t20 PROPERTIES
         CXX_STANDARD_REQUIRED ON
         CXX_EXTENSIONS ON
         )
+target_compile_options(t20
+	    PRIVATE
+		-fsyntax-only
+		)
 target_sources(t20 PRIVATE etl_profile.h
         ../absolute.h.t.cpp
         ../algorithm.h.t.cpp
@@ -123,6 +127,8 @@ target_sources(t20 PRIVATE etl_profile.h
         ../crc8_maxim.h.t.cpp
         ../crc8_rohc.h.t.cpp
         ../crc8_wcdma.h.t.cpp
+        ../crc8_j1850.h.t.cpp
+        ../crc8_j1850_zero.h.t.cpp
         ../cyclic_value.h.t.cpp
         ../debounce.h.t.cpp
         ../debug_count.h.t.cpp
diff --git a/test/syntax_check/crc8_j1850.h.t.cpp b/test/syntax_check/crc8_j1850.h.t.cpp
new file mode 100644
index 00000000..5e16709f
--- /dev/null
+++ b/test/syntax_check/crc8_j1850.h.t.cpp
@@ -0,0 +1,29 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2024 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#include <etl/crc8_j1850.h>
diff --git a/test/syntax_check/crc8_j1850_zero.h.t.cpp b/test/syntax_check/crc8_j1850_zero.h.t.cpp
new file mode 100644
index 00000000..ec892d09
--- /dev/null
+++ b/test/syntax_check/crc8_j1850_zero.h.t.cpp
@@ -0,0 +1,29 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2024 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#include <etl/crc8_j1850_zero.h>
diff --git a/test/test_algorithm.cpp b/test/test_algorithm.cpp
index a49e0011..875884c6 100644
--- a/test/test_algorithm.cpp
+++ b/test/test_algorithm.cpp
@@ -30,6 +30,7 @@ SOFTWARE.
 
 #include "etl/algorithm.h"
 #include "etl/container.h"
+#include "etl/binary.h"
 
 #include "data.h"
 #include "iterators_for_unit_tests.h"
@@ -84,9 +85,9 @@ namespace
     {
     }
 
-    Data(int a, int b)
-      : a(a)
-      , b(b)
+    Data(int a_, int b_)
+      : a(a_)
+      , b(b_)
     {
     }
 
@@ -2198,5 +2199,190 @@ namespace
       bool is_same = std::equal(expected.begin(), expected.end(), data.begin());
       CHECK(is_same);
     }
+
+    //*************************************************************************
+    struct generator
+    {
+      generator(int value_)
+        : value(value_)
+      {
+      }
+
+      int operator()()
+      {
+        return value++;
+      }
+
+      int value;
+    };
+
+    TEST(generate)
+    {
+      std::array<int, 10> expected = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+      std::array<int, 10> actual;
+
+      etl::generate(actual.begin(), actual.end(), generator(2));
+
+      CHECK_ARRAY_EQUAL(expected.data(), actual.data(), expected.size());
+    }
+
+    //*************************************************************************
+    TEST(partition_forward_iterator_container)
+    {
+      // 40,320 permutations.
+      std::array<int, 8> origin = { 0, 1, 2, 3, 4, 5, 6, 7 };
+
+      std::forward_list<int> compare(origin.begin(), origin.end());
+      std::forward_list<int> data(origin.begin(), origin.end());
+
+      bool complete = false;
+
+      while (!complete)
+      {
+        auto pivot1 = std::partition(compare.begin(), compare.end(), [](int i) { return etl::is_even(i); });
+        auto pivot2 = etl::partition(data.begin(), data.end(), [](int i) { return etl::is_even(i); });
+
+        auto distance1 = std::distance(compare.begin(), pivot1);
+        auto distance2 = std::distance(data.begin(), pivot2);
+
+        CHECK_EQUAL(*pivot1, *pivot2);
+        CHECK_EQUAL(distance1, distance2);
+
+        for (auto itr = compare.begin(); itr != pivot1; ++itr)
+        {
+          CHECK_TRUE((etl::is_even(*itr)));
+        }
+
+        for (auto itr = pivot1; itr != compare.end(); ++itr)
+        {
+          CHECK_FALSE((etl::is_even(*itr)));
+        }
+
+        complete = !std::next_permutation(origin.begin(), origin.end());
+
+        compare.assign(origin.begin(), origin.end());
+        data.assign(origin.begin(), origin.end());
+      }
+    }
+
+    //*************************************************************************
+    TEST(partition_bidirectional_iterator_container)
+    {
+      // 40,320 permutations.
+      std::array<int, 8> initial = { 0, 1, 2, 3, 4, 5, 6, 7 };
+      
+      std::array<int, 8> compare = initial;
+      std::array<int, 8> data = initial;
+
+      bool complete = false;
+
+      while (!complete)
+      {
+        auto pivot1 = std::partition(compare.begin(), compare.end(), [](int i) { return etl::is_even(i); });
+        auto pivot2 = etl::partition(data.begin(), data.end(), [](int i) { return etl::is_even(i); });
+
+        auto distance1 = std::distance(compare.begin(), pivot1);
+        auto distance2 = std::distance(data.begin(), pivot2);
+
+        CHECK_EQUAL(*pivot1, *pivot2);
+        CHECK_EQUAL(distance1, distance2);
+
+        for (auto itr = compare.begin(); itr != pivot1; ++itr)
+        {
+          CHECK_TRUE((etl::is_even(*itr)));
+        }
+
+        for (auto itr = pivot1; itr != compare.end(); ++itr)
+        {
+          CHECK_FALSE((etl::is_even(*itr)));
+        }
+
+        complete = !std::next_permutation(initial.begin(), initial.end());
+
+        compare = initial;
+        data = initial;
+      }
+    }
+
+    //*************************************************************************
+    TEST(nth_element_with_default_less_than_comparison)
+    {
+      // 40,320 permutations.
+      std::array<int, 8> initial = { 0, 1, 2, 3, 4, 5, 6, 7 };
+
+      std::array<int, 8> compare = initial;
+      std::array<int, 8> data    = initial;
+
+      bool complete = false;
+
+      // For each nth position of each permutation.
+      while (!complete)
+      {
+        // Try each nth position.
+        for (size_t i = 0; i < initial.size(); ++i)
+        {
+          std::sort(compare.begin(), compare.end());
+          etl::nth_element(data.begin(), data.begin() + i, data.end());
+
+          CHECK_EQUAL(compare[i], data[i]);
+        }
+
+        complete = !std::next_permutation(initial.begin(), initial.end());
+
+        compare = initial;
+        data    = initial;
+      }
+    }
+
+#if (ETL_USING_CPP20 && ETL_USING_STL) || (ETL_USING_CPP14 && ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST))
+    //*************************************************************************
+    constexpr int MakeNth(int nth_index)
+    {
+      std::array<int, 8> data = { 5, 1, 3, 7, 6, 2, 4, 0 };
+
+      etl::nth_element(data.begin(), data.begin() + nth_index, data.end());
+
+      return data[nth_index];
+    }
+    
+    TEST(constexpr_nth_element_with_default_less_than_comparison)
+    {
+      std::array<int, 8> compare = { 0, 1, 2, 3, 4, 5, 6, 7 };
+
+      constexpr int nth = MakeNth(3);
+
+      CHECK_EQUAL(compare[3], nth);
+    }
+#endif
+
+    //*************************************************************************
+    TEST(nth_element_with_custom_comparison)
+    {
+      // 40,320 permutations.
+      std::array<int, 8> initial = { 0, 1, 2, 3, 4, 5, 6, 7 };
+
+      std::array<int, 8> compare = initial;
+      std::array<int, 8> data = initial;
+
+      bool complete = false;
+
+      // For each nth position of each permutation.
+      while (!complete)
+      {
+        // Try each nth position.
+        for (size_t i = 0; i < initial.size(); ++i)
+        {
+          std::sort(compare.begin(), compare.end(), std::greater<int>());
+          etl::nth_element(data.begin(), data.begin() + i, data.end(), std::greater<int>());
+
+          CHECK_EQUAL(compare[i], data[i]);
+        }
+
+        complete = !std::next_permutation(initial.begin(), initial.end());
+
+        compare = initial;
+        data = initial;
+      }
+    }
   };
 }
diff --git a/test/test_array.cpp b/test/test_array.cpp
index 122755c1..bc192c53 100644
--- a/test/test_array.cpp
+++ b/test/test_array.cpp
@@ -375,20 +375,27 @@ namespace
 
       Data data = { 0 };
 
+      Data::iterator result;
+
       // Initial data.
-      data.assign(std::begin(initial), std::end(initial));
+      result = data.assign(std::begin(initial), std::end(initial));
+      CHECK(result == data.end());
       bool isEqual = std::equal(data.begin(), data.end(), std::begin(initial));
       CHECK(isEqual);
 
       // Assign smaller.
-      data.assign(std::begin(initial), std::end(initial));
-      data.assign(&source[0], &source[5]);
+      result = data.assign(std::begin(initial), std::end(initial));
+      CHECK(result == data.end());
+      result = data.assign(&source[0], &source[5]);
+      CHECK(result == &data[5]);
       isEqual = std::equal(data.begin(), data.end(), std::begin(check1));
       CHECK(isEqual);
 
       // Assign smaller + default.
-      data.assign(std::begin(initial), std::end(initial));
-      data.assign(&source[0], &source[5], 99);
+      result = data.assign(std::begin(initial), std::end(initial));
+      CHECK(result == data.end());
+      result = data.assign(&source[0], &source[5], 99);
+      CHECK(result == &data[5]);
       isEqual = std::equal(data.begin(), data.end(), std::begin(check2));
       CHECK(isEqual);
     }
diff --git a/test/test_binary.cpp b/test/test_binary.cpp
index 56e5157d..3e93bbb7 100644
--- a/test/test_binary.cpp
+++ b/test/test_binary.cpp
@@ -31,6 +31,8 @@ SOFTWARE.
 #include <cstdint>
 #include <type_traits>
 #include <limits>
+#include <array>
+#include <algorithm>
 
 #include "etl/binary.h"
 #include "etl/bitset.h"
@@ -42,6 +44,15 @@ SOFTWARE.
 
 namespace
 {
+  template <typename TIterator, typename T>
+  void generate_input(TIterator first, TIterator last, T value)
+  {
+    while (first != last)
+    {
+      *first++ = value++;
+    }
+  }
+
   //***********************************
   // Count bits the easy way.
   template <typename T>
@@ -2894,6 +2905,101 @@ namespace
       CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFF00), (etl::make_msb_mask<int64_t, 56>()));
       CHECK_EQUAL(int64_t(0xFFFFFFFFFFFFFFFF), (etl::make_msb_mask<int64_t, 64>()));
     }
+
+    //*************************************************************************
+    TEST(test_binary_not)
+    {
+      std::array<uint8_t, 256> input;
+      generate_input(input.begin(), input.end(), 0);
+
+      std::array<uint8_t, 256> expected;
+      for (size_t i = 0; i < input.size(); ++i)
+      {
+        expected[i] = ~input[i];
+      }
+
+      std::array<uint8_t, 256> output;
+
+      std::transform(input.begin(),
+                     input.end(),
+                     output.begin(),
+                     etl::binary_not<uint8_t>());
+
+      CHECK_ARRAY_EQUAL(expected.data(), output.data(), expected.size());
+    }
+
+    //*************************************************************************
+    TEST(test_binary_and)
+    {
+      std::array<uint8_t, 256> input;
+      generate_input(input.begin(), input.end(), 0);
+
+      const uint8_t value = etl::b01101001;
+
+      std::array<uint8_t, 256> expected;
+      for (size_t i = 0; i < input.size(); ++i)
+      {
+        expected[i] = input[i] & value;
+      }
+
+      std::array<uint8_t, 256> output;
+
+      std::transform(input.begin(),
+                     input.end(), 
+                     output.begin(), 
+                     etl::binary_and<uint8_t>(value));
+
+      CHECK_ARRAY_EQUAL(expected.data(), output.data(), expected.size());
+    }
+
+    //*************************************************************************
+    TEST(test_binary_or)
+    {
+      std::array<uint8_t, 256> input;
+      generate_input(input.begin(), input.end(), 0);
+
+      const uint8_t value = etl::b01101001;
+
+      std::array<uint8_t, 256> expected;
+      for (size_t i = 0; i < input.size(); ++i)
+      {
+        expected[i] = input[i] | value;
+      }
+
+      std::array<uint8_t, 256> output;
+
+      std::transform(input.begin(),
+                     input.end(),
+                     output.begin(),
+                     etl::binary_or<uint8_t>(value));
+
+      CHECK_ARRAY_EQUAL(expected.data(), output.data(), expected.size());
+    }
+
+    //*************************************************************************
+    TEST(test_binary_xor)
+    {
+      std::array<uint8_t, 256> input;
+      generate_input(input.begin(), input.end(), 0);
+
+      const uint8_t value = etl::b01101001;
+
+      std::array<uint8_t, 256> expected;
+
+      for (size_t i = 0; i < input.size(); ++i)
+      {
+        expected[i] = input[i] ^ value;
+      }
+
+      std::array<uint8_t, 256> output;
+
+      std::transform(input.begin(),
+                     input.end(),
+                     output.begin(),
+                     etl::binary_xor<uint8_t>(value));
+
+      CHECK_ARRAY_EQUAL(expected.data(), output.data(), expected.size());
+    }
   };
 }
 
diff --git a/test/test_bit_stream_reader_big_endian.cpp b/test/test_bit_stream_reader_big_endian.cpp
index c71977b1..4cdf3d29 100644
--- a/test/test_bit_stream_reader_big_endian.cpp
+++ b/test/test_bit_stream_reader_big_endian.cpp
@@ -94,7 +94,7 @@ namespace etl
 
 namespace
 {
-  SUITE(test_bit_stream_reader)
+  SUITE(test_bit_stream_reader_big_endian)
   {
     //*************************************************************************
     TEST(test_read_bool)
diff --git a/test/test_bit_stream_reader_little_endian.cpp b/test/test_bit_stream_reader_little_endian.cpp
index 776d2023..22c724ff 100644
--- a/test/test_bit_stream_reader_little_endian.cpp
+++ b/test/test_bit_stream_reader_little_endian.cpp
@@ -95,7 +95,7 @@ namespace etl
 
 namespace
 {
-  SUITE(test_bit_stream_reader)
+  SUITE(test_bit_stream_reader_little_endian)
   {
     //*************************************************************************
     TEST(test_read_bool)
diff --git a/test/test_bit_stream_writer_big_endian.cpp b/test/test_bit_stream_writer_big_endian.cpp
index be7ff681..675edbbb 100644
--- a/test/test_bit_stream_writer_big_endian.cpp
+++ b/test/test_bit_stream_writer_big_endian.cpp
@@ -114,7 +114,7 @@ namespace
     std::vector<char> data;
   };
 
-  SUITE(test_bit_stream_big_endian)
+  SUITE(test_bit_stream_writer_big_endian)
   {
     //*************************************************************************
     TEST(test_bit_stream_writer_construction)
diff --git a/test/test_bit_stream_writer_little_endian.cpp b/test/test_bit_stream_writer_little_endian.cpp
index e66c46c2..3051bc7f 100644
--- a/test/test_bit_stream_writer_little_endian.cpp
+++ b/test/test_bit_stream_writer_little_endian.cpp
@@ -114,7 +114,7 @@ namespace
     std::vector<char> data;
   };
 
-  SUITE(test_bit_stream_little_endian)
+  SUITE(test_bit_stream_writer_little_endian)
   {
     //*************************************************************************
     TEST(test_bit_stream_writer_construction)
diff --git a/test/test_bitset_legacy.cpp b/test/test_bitset_legacy.cpp
index ce664c4c..a64722ba 100644
--- a/test/test_bitset_legacy.cpp
+++ b/test/test_bitset_legacy.cpp
@@ -143,6 +143,50 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char_string)
+    {
+      const char* s = nullptr;
+
+      etl::bitset<60> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_wchar_t_string)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset<60> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char16_t_string)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset<60> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char32_t_string)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset<60> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
     //*************************************************************************
     TEST(test_construct_from_excess_string)
     {
@@ -206,7 +250,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char_string_set)
+    TEST(test_set_with_char_string)
     {
       std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
       etl::bitset<60> data;
@@ -226,7 +270,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_wchar_t_string_set)
+    TEST(test_set_with_wchar_t_string)
     {
       std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
       etl::bitset<60> data;
@@ -246,7 +290,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char16_t_string_set)
+    TEST(test_set_with_char16_t_string)
     {
       std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
       etl::bitset<60> data;
@@ -266,7 +310,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char32_t_string_set)
+    TEST(test_set_with_char32_t_string)
     {
       std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
       etl::bitset<60> data;
@@ -286,7 +330,55 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char_string)
+    TEST(test_set_from_char_nullptr)
+    {
+      const char* s = nullptr;
+
+      etl::bitset<60> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char32_t_nullptr)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char)
     {
       std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
       etl::bitset<60> data;
@@ -306,7 +398,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_wchar_t_string)
+    TEST(test_from_string_with_wchar_t)
     {
       std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
       etl::bitset<60> data;
@@ -346,7 +438,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char32_t_string)
+    TEST(test_from_string_with_char32_t)
     {
       std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
       etl::bitset<60> data;
@@ -365,6 +457,54 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_from_string_with_char_nullptr)
+    {
+      const char* s = nullptr;
+
+      etl::bitset<60> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char32_t_nullptr)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
     //*************************************************************************
     TEST(test_value_u8_min)
     {
diff --git a/test/test_bitset_new_comparisons.cpp b/test/test_bitset_new_comparisons.cpp
new file mode 100644
index 00000000..4436982f
--- /dev/null
+++ b/test/test_bitset_new_comparisons.cpp
@@ -0,0 +1,239 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2022 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#include "unit_test_framework.h"
+
+#include "etl/private/bitset_new.h"
+
+namespace
+{
+  using ull = unsigned long long;
+
+  SUITE(test_bitset_new_comparisons)
+  {
+    //*************************************************************************
+    TEST(test_equality_single_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x0123456789012345ULL);
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data3(0x0123456789012345ULL, buffer3);
+      etl::bitset_ext<64, uint64_t> data4(0x0123456789012345ULL, buffer4);
+
+      // Double check we are using the single element storage model.
+      CHECK(etl::bitset_storage_model::Single == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data4.Storage_Model);
+
+      CHECK(data1 == data2); // bitset     == bitset
+      CHECK(data1 == data3); // bitset     == bitset_ext
+      CHECK(data3 == data1); // bitset_ext == bitset
+      CHECK(data3 == data4); // bitset_ext == bitset_ext
+    }
+
+    //*************************************************************************
+    TEST(test_inequality_single_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x0123456784012345ULL);
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data3(0x0123456787012345ULL, buffer3);
+      etl::bitset_ext<64, uint64_t> data4(0x0123426789012345ULL, buffer4);
+
+      // Double check we are using the single element storage model.
+      CHECK(etl::bitset_storage_model::Single == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data4.Storage_Model);
+
+      CHECK(data1 != data2); // bitset     != bitset
+      CHECK(data1 != data3); // bitset     != bitset_ext
+      CHECK(data3 != data1); // bitset_ext != bitset
+      CHECK(data3 != data4); // bitset_ext != bitset_ext
+    }
+
+    //*************************************************************************
+    TEST(test_equality_multi_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456789012345ULL);
+
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data3(0x0123456789012345ULL, buffer3);
+      etl::bitset_ext<64> data4(0x0123456789012345ULL, buffer4);
+
+      // Double check we are using the multi element storage model.
+      CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model);
+
+      CHECK(data1 == data2); // bitset     == bitset
+      CHECK(data1 == data3); // bitset     == bitset_ext
+      CHECK(data3 == data1); // bitset_ext == bitset
+      CHECK(data3 == data4); // bitset_ext == bitset_ext
+    }
+
+    //*************************************************************************
+    TEST(test_inequality_multi_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456784012345ULL);
+
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data3(0x0123456787012345ULL, buffer3);
+      etl::bitset_ext<64> data4(0x0123426789012345ULL, buffer4);
+
+      // Double check we are using the multi element storage model.
+      CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model);
+
+      CHECK(data1 != data2); // bitset     != bitset
+      CHECK(data1 != data3); // bitset     != bitset_ext
+      CHECK(data3 != data1); // bitset_ext != bitset
+      CHECK(data3 != data4); // bitset_ext != bitset_ext
+    }
+
+    //*************************************************************************
+    TEST(test_equality_mixed_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456789012345ULL);
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data3(0x0123456789012345ULL, buffer3);
+      etl::bitset_ext<64> data4(0x0123456789012345ULL, buffer4);
+
+      // Double check we are using the single/multi element storage model.
+      CHECK(etl::bitset_storage_model::Single == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi  == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi  == data4.Storage_Model);
+
+      CHECK(data1 == data2); // bitset     (S) == bitset     (M)
+      CHECK(data2 == data1); // bitset     (M) == bitset     (S)
+      CHECK(data3 == data4); // bitset_ext (S) == bitset_ext (M)
+      CHECK(data4 == data3); // bitset_ext (M) == bitset_ext (S)
+      CHECK(data1 == data4); // bitset     (S) == bitset_ext (M)
+      CHECK(data4 == data1); // bitset_ext (M) == bitset     (S)
+      CHECK(data2 == data3); // bitset     (M) == bitset_ext (S)
+      CHECK(data3 == data2); // bitset_ext (S) == bitset     (M)
+    }
+
+    //*************************************************************************
+    TEST(test_inequality_mixed_storage_model)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456784012345ULL);
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data3(0x0123456787012345ULL, buffer3);
+      etl::bitset_ext<64> data4(0x0123426789012345ULL, buffer4);
+
+      // Double check we are using the single/multi element storage model.
+      CHECK(etl::bitset_storage_model::Single == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi  == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Single == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi  == data4.Storage_Model);
+
+      CHECK(data1 != data2); // bitset     (S) != bitset     (M)
+      CHECK(data2 != data1); // bitset     (M) != bitset     (S)
+      CHECK(data3 != data4); // bitset_ext (S) != bitset_ext (M)
+      CHECK(data4 != data3); // bitset_ext (M) != bitset_ext (S)
+      CHECK(data1 != data4); // bitset     (S) != bitset_ext (M)
+      CHECK(data4 != data1); // bitset_ext (M) != bitset     (S)
+      CHECK(data2 != data3); // bitset     (M) != bitset_ext (S)
+      CHECK(data3 != data2); // bitset_ext (S) != bitset     (M) 
+    }
+
+    //*************************************************************************
+    TEST(test_equality_mixed_storage_model_different_element_types)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint32_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint8_t>  data2(0x0123456789012345ULL);
+
+      etl::bitset_ext<64, uint32_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint8_t>::buffer_type  buffer4;
+      etl::bitset_ext<64, uint32_t> data3(0x0123456789012345ULL, buffer3);
+      etl::bitset_ext<64, uint8_t>  data4(0x0123456789012345ULL, buffer4);
+
+      // Double check we are using the multi element storage model.
+      CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model);
+
+      CHECK(data1 == data2); // bitset     (S) == bitset     (M)
+      CHECK(data2 == data1); // bitset     (M) == bitset     (S)
+      CHECK(data3 == data4); // bitset_ext (S) == bitset_ext (M)
+      CHECK(data4 == data3); // bitset_ext (M) == bitset_ext (S)
+      CHECK(data1 == data4); // bitset     (S) == bitset_ext (M)
+      CHECK(data4 == data1); // bitset_ext (M) == bitset     (S)
+      CHECK(data2 == data3); // bitset     (M) == bitset_ext (S)
+      CHECK(data3 == data2); // bitset_ext (S) == bitset     (M)
+    }
+
+    //*************************************************************************
+    TEST(test_inequality_mixed_storage_model_different_element_types)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64, uint32_t> data1(0x0123456789012345ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint8_t>  data2(0x0123456784012345ULL);
+
+      etl::bitset_ext<64, uint32_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint8_t>::buffer_type  buffer4;
+      etl::bitset_ext<64, uint32_t> data3(0x0123456787012345ULL, buffer3);
+      etl::bitset_ext<64, uint8_t>  data4(0x0123426789012345ULL, buffer4);
+
+      // Double check we are using the multi element storage model.
+      CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model);
+      CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model);
+
+      CHECK(data1 != data2); // bitset     (S) != bitset     (M)
+      CHECK(data2 != data1); // bitset     (M) != bitset     (S)
+      CHECK(data3 != data4); // bitset_ext (S) != bitset_ext (M)
+      CHECK(data4 != data3); // bitset_ext (M) != bitset_ext (S)
+      CHECK(data1 != data4); // bitset     (S) != bitset_ext (M)
+      CHECK(data4 != data1); // bitset_ext (M) != bitset     (S)
+      CHECK(data2 != data3); // bitset     (M) != bitset_ext (S)
+      CHECK(data3 != data2); // bitset_ext (S) != bitset     (M)
+    }
+  };
+}
diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp
index 67f703a3..81d4158d 100644
--- a/test/test_bitset_new_default_element_type.cpp
+++ b/test/test_bitset_new_default_element_type.cpp
@@ -37,6 +37,7 @@ SOFTWARE.
 #include "etl/wstring.h"
 #include "etl/u16string.h"
 #include "etl/u32string.h"
+#include "etl/endianness.h"
 
 namespace
 {
@@ -46,9 +47,22 @@ namespace
   template <size_t Active_Bits>
   ETL_CONSTEXPR14 etl::bitset<Active_Bits> generate_shift_left_bitset(ull value, size_t shift)
   {
+    ull mask = 0ULL;
+
+    if (shift < 64U)
+    {
+      mask = etl::integral_limits<ull>::max >> shift;
+    }
+
+    value &= mask;
+
     etl::bitset<Active_Bits> data(value);
 
-    if (shift != 0U)
+    if (shift >= 64U)
+    {
+      data.reset();
+    }
+    else if (shift != 0U)
     {
       data <<= shift;
     }
@@ -63,7 +77,7 @@ namespace
     etl::bitset<Active_Bits> data1(value);
     etl::bitset<Active_Bits> data2;
 
-    if (shift != 0U)
+    if ((shift != 0U) && (shift != 64U))
     {
       data2 = data1 << shift;
     }
@@ -77,7 +91,11 @@ namespace
   {
     etl::bitset<Active_Bits> data(value);
 
-    if (shift != 0U)
+    if (shift >= 64U)
+    {
+      data.reset();
+    }
+    else if (shift != 0U)
     {
       data >>= shift;
     }
@@ -102,13 +120,84 @@ namespace
 
   SUITE(test_bitset_new_default_element_type)
   {
+    //*************************************************************************
+    TEST(test_constants)
+    {
+      using bitset_type  = etl::bitset<60>;
+      using element_type = bitset_type::element_type;
+
+      constexpr size_t       Size               = 60;
+      constexpr size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
+      constexpr size_t       Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
+      constexpr element_type All_Set_Element    = etl::integral_limits<element_type>::max;
+      constexpr element_type All_Clear_Element  = etl::integral_limits<element_type>::min;
+
+      //*******************************
+      constexpr size_t Size1 = bitset_type::Size;
+      constexpr size_t Size2 = bitset_type::size();
+
+      CHECK_EQUAL(Size, Size1);
+      CHECK_EQUAL(Size, Size2);
+
+      //*******************************
+      constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
+      constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
+
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
+
+      //*******************************
+      constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
+      constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
+      
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
+
+      //*******************************
+      constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
+      constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
+
+      CHECK_EQUAL(All_Set_Element, All_Set_Element1);
+      CHECK_EQUAL(All_Set_Element, All_Set_Element2);
+
+      //*******************************
+      constexpr size_t All_Clear_Element1 = bitset_type::All_Clear_Element;
+      constexpr size_t All_Clear_Element2 = bitset_type::all_clear_element();
+
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
+
+      //*******************************
+      constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
+
+      CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
+
+      //*******************************
+      constexpr char Storage_Model1 = bitset_type::Storage_Model;
+      constexpr char Storage_Model2 = bitset_type::storage_model();
+
+      CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model1);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model2);
+
+      etl::bitset_storage_model bsm;
+      
+      bsm = etl::bitset_storage_model::Undefined;
+      CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Single;
+      CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Multi;
+      CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
+    }
+
     //*************************************************************************
     TEST(test_default_constructor)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare;
-      ETL_CONSTEXPR14 etl::bitset<60> data;
+      ETL_CONSTEXPR14 std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data;
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -118,715 +207,41 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_default_constructor_multi_element)
+    TEST(test_default_constructor_single_element)
     {
-      etl::bitset<14, int8_t>  data8;
-      etl::bitset<30, int16_t> data16;
-      etl::bitset<62, int32_t> data32;
+      etl::bitset<8>  data8;
+      etl::bitset<16> data16;
+      etl::bitset<32> data32;
+      etl::bitset<64> data64;
 
-      CHECK_EQUAL(2U, data8.Number_Of_Elements);
-      CHECK_EQUAL(2U, data16.Number_Of_Elements);
-      CHECK_EQUAL(2U, data32.Number_Of_Elements);
-    }
+      using element_type  = etl::bitset<8>::element_type;
+      size_t element_bits = etl::integral_limits<element_type>::bits;
 
-    //*************************************************************************
-    TEST(test_default_constructor_default_element_type_bits)
-    {
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<1>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<2>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<3>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<4>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<5>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<6>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<7>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<8>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<9>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<10>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<11>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<12>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<13>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<14>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<15>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<16>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<17>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<18>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<19>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<20>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<21>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<22>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<23>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<24>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<25>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<26>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<27>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<28>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<29>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<30>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<31>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<32>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<33>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<34>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<35>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<36>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<37>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<38>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<39>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<40>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<41>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<42>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<43>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<44>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<45>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<46>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<47>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<48>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<49>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<50>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<51>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<52>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<53>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<54>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<55>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<56>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<57>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<58>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<59>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<60>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<61>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<62>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<63>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset<64>::element_type>::bits);
-    }
-     
-    //*************************************************************************
-    TEST(test_default_constructor_default_element_type_number_of_elements)
-    {
-      CHECK_EQUAL(1U, etl::bitset<1>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<2>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<3>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<4>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<5>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<6>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<7>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset<8>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<9>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<10>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<11>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<12>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<13>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<14>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<15>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset<16>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<17>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<18>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<19>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<20>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<21>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<22>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<23>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset<24>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<25>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<26>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<27>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<28>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<29>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<30>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<31>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset<32>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<33>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<34>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<35>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<36>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<37>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<38>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<39>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset<40>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<41>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<42>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<43>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<44>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<45>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<46>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<47>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset<48>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<49>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<50>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<51>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<52>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<53>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<54>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<55>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset<56>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<57>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<58>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<59>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<60>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<61>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<62>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<63>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset<64>::Number_Of_Elements);
-    }
+      CHECK_EQUAL(8,  data8.Size);
+      CHECK_EQUAL(16, data16.Size);
+      CHECK_EQUAL(32, data32.Size);
+      CHECK_EQUAL(64, data64.Size);
 
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int8_t_element_types_bits)
-    {
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<1, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<2, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<3, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<4, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<5, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<6, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<7, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<8, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<9, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<10, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<11, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<12, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<13, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<14, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<15, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<16, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<17, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<18, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<19, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<20, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<21, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<22, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<23, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<24, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<25, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<26, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<27, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<28, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<29, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<30, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<31, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<32, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<33, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<34, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<35, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<36, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<37, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<38, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<39, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<40, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<41, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<42, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<43, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<44, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<45, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<46, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<47, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<48, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<49, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<50, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<51, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<52, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<53, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<54, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<55, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<56, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<57, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<58, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<59, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<60, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<61, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<62, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<63, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset<64, int8_t>::element_type>::bits));
-    }
+      CHECK_EQUAL( 8 / element_bits, data8.Number_Of_Elements);
+      CHECK_EQUAL(16 / element_bits, data16.Number_Of_Elements);
+      CHECK_EQUAL(32 / element_bits, data32.Number_Of_Elements);
+      CHECK_EQUAL(64 / element_bits, data64.Number_Of_Elements);
 
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int8_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset<1, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<2, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<3, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<4, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<5, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<6, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<7, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<8, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<9, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<10, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<11, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<12, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<13, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<14, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<15, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<16, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<17, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<18, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<19, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<20, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<21, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<22, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<23, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<24, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<25, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<26, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<27, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<28, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<29, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<30, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<31, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<32, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<33, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<34, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<35, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<36, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<37, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<38, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<39, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset<40, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<41, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<42, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<43, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<44, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<45, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<46, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<47, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset<48, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<49, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<50, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<51, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<52, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<53, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<54, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<55, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset<56, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<57, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<58, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<59, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<60, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<61, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<62, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<63, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset<64, int8_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int16_t_element_types_bits)
-    {
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<1, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<2, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<3, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<4, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<5, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<6, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<7, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<8, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<9, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<10, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<11, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<12, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<13, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<14, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<15, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<16, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<17, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<18, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<19, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<20, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<21, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<22, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<23, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<24, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<25, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<26, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<27, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<28, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<29, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<30, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<31, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<32, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<33, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<34, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<35, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<36, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<37, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<38, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<39, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<40, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<41, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<42, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<43, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<44, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<45, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<46, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<47, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<48, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<49, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<50, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<51, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<52, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<53, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<54, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<55, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<56, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<57, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<58, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<59, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<60, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<61, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<62, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<63, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset<64, int16_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int16_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset<1, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<2, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<3, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<4, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<5, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<6, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<7, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<8, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<9, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<10, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<11, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<12, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<13, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<14, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<15, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<16, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<17, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<18, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<19, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<20, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<21, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<22, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<23, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<24, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<25, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<26, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<27, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<28, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<29, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<30, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<31, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<32, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<33, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<34, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<35, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<36, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<37, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<38, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<39, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<40, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<41, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<42, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<43, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<44, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<45, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<46, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<47, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset<48, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<49, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<50, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<51, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<52, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<53, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<54, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<55, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<56, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<57, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<58, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<59, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<60, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<61, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<62, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<63, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset<64, int16_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int32_t_element_types_bits)
-    {
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<1, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<2, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<3, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<4, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<5, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<6, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<7, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<8, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<9, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<10, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<11, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<12, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<13, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<14, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<15, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<16, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<17, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<18, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<19, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<20, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<21, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<22, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<23, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<24, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<25, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<26, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<27, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<28, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<29, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<30, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<31, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<32, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<33, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<34, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<35, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<36, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<37, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<38, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<39, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<40, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<41, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<42, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<43, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<44, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<45, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<46, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<47, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<48, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<49, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<50, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<51, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<52, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<53, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<54, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<55, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<56, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<57, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<58, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<59, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<60, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<61, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<62, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<63, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset<64, int32_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int32_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset<1, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<2, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<3, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<4, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<5, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<6, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<7, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<8, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<9, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<10, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<11, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<12, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<13, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<14, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<15, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<16, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<17, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<18, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<19, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<20, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<21, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<22, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<23, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<24, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<25, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<26, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<27, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<28, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<29, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<30, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<31, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<32, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<33, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<34, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<35, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<36, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<37, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<38, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<39, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<40, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<41, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<42, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<43, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<44, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<45, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<46, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<47, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<48, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<49, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<50, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<51, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<52, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<53, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<54, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<55, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<56, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<57, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<58, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<59, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<60, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<61, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<62, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<63, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset<64, int32_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int64_t_element_types_bits)
-    {
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<1, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<2, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<3, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<4, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<5, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<6, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<7, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<8, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<9, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<10, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<11, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<12, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<13, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<14, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<15, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<16, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<17, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<18, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<19, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<20, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<21, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<22, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<23, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<24, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<25, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<26, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<27, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<28, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<29, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<30, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<31, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<32, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<33, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<34, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<35, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<36, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<37, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<38, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<39, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<40, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<41, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<42, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<43, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<44, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<45, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<46, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<47, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<48, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<49, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<50, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<51, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<52, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<53, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<54, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<55, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<56, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<57, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<58, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<59, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<60, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<61, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<62, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<63, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset<64, int64_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int64_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset<1, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<2, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<3, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<4, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<5, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<6, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<7, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<8, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<9, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<10, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<11, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<12, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<13, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<14, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<15, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<16, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<17, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<18, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<19, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<20, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<21, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<22, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<23, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<24, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<25, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<26, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<27, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<28, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<29, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<30, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<31, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<32, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<33, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<34, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<35, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<36, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<37, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<38, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<39, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<40, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<41, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<42, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<43, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<44, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<45, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<46, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<47, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<48, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<49, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<50, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<51, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<52, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<53, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<54, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<55, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<56, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<57, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<58, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<59, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<60, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<61, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<62, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<63, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset<64, int64_t>::Number_Of_Elements));
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data8.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi,  data16.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi,  data32.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi,  data64.Storage_Model);
     }
 
     //*************************************************************************
     TEST(test_construct_from_value)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data(0x123456731234567ULL);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(0x123456731234567ULL);
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
+      CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -837,9 +252,9 @@ namespace
     //*************************************************************************
     TEST(test_copy_construct)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data_copy(data);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data_copy(data);
 
       CHECK_EQUAL(compare.size(), data_copy.size());
       CHECK_EQUAL(compare.count(), data_copy.count());
@@ -853,10 +268,10 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_excess_value)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare(0x8765432187654321ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data(0x8765432187654321ULL);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0x8765432187654321ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(0x8765432187654321ULL);
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -868,10 +283,10 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char_string)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001");
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data("110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -883,8 +298,8 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_wchar_t_string)
     {
-      std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data(L"110001001000110100010101100111001100010010001101000101011001");
+      std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data(L"110001001000110100010101100111001100010010001101000101011001");
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -898,8 +313,8 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char16_t_string)
     {
-      std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data(u"110001001000110100010101100111001100010010001101000101011001");
+      std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data(u"110001001000110100010101100111001100010010001101000101011001");
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -913,8 +328,8 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char32_t_string)
     {
-      std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data(U"110001001000110100010101100111001100010010001101000101011001");
+      std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data(U"110001001000110100010101100111001100010010001101000101011001");
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -925,11 +340,55 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char_string)
+    {
+      const char* s = nullptr;
+
+      etl::bitset<60> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_wchar_t_string)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset<60> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char16_t_string)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset<60> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char32_t_string)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset<60> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
     //*************************************************************************
     TEST(test_construct_from_excess_string)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001111100001");
-      etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001111100001");
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001");
+      etl::bitset<64> data("110001001000110100010101100111001100010010001101000101011001111100001");
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -937,6 +396,8 @@ namespace
       CHECK_EQUAL(compare.any(),   data.any());
       CHECK_EQUAL(compare.all(),   data.all());
 
+      CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong());
+
       for (size_t i = 0UL; i < data.size(); ++i)
       {
         CHECK_EQUAL(compare.test(i), data.test(i));
@@ -944,7 +405,41 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_helper()
+    {
+      etl::bitset<64> data;
+      data.set();
+
+      return data;
+    }
+
     TEST(test_set)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_helper());
+
+      compare.set();
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_less_than_full_size)
     {
       std::bitset<60> compare;
       etl::bitset<60> data;
@@ -952,11 +447,17 @@ namespace
       compare.set();
       data.set();
 
-      CHECK_EQUAL(compare.size(), data.size());
-      CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -965,10 +466,285 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char_string_set)
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_run_time_position_default_value_helper()
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      etl::bitset<64> data;
+
+      data.set(2);
+      data.set(3);
+      data.set(5);
+      data.set(7);
+      data.set(11);
+      data.set(13);
+      data.set(17);
+      data.set(19);
+      data.set(23);
+      data.set(29);
+      data.set(31);
+
+      return data;
+    }
+
+    TEST(test_set_run_time_position_default_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_run_time_position_default_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_run_time_position_value_helper()
+    {
+      etl::bitset<64> data;
+
+      data.set(2, true);
+      data.set(3, true);
+      data.set(5, true);
+      data.set(7, true);
+      data.set(11, true);
+      data.set(13, true);
+      data.set(17, true);
+      data.set(19, true);
+      data.set(23, true);
+      data.set(29, true);
+      data.set(31, true);
+
+      return data;
+    }
+
+    TEST(test_set_run_time_position_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_run_time_position_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_compile_time_position_run_time_default_value_helper()
+    {
+      etl::bitset<64> data;
+
+      data.set<2>();
+      data.set<3>();
+      data.set<5>();
+      data.set<7>();
+      data.set<11>();
+      data.set<13>();
+      data.set<17>();
+      data.set<19>();
+      data.set<23>();
+      data.set<29>();
+      data.set<31>();
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_run_time_default_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_compile_time_position_run_time_default_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_compile_time_position_run_time_value_helper()
+    {
+      etl::bitset<64> data;
+
+      data.set<2>(true);
+      data.set<3>(true);
+      data.set<5>(true);
+      data.set<7>(true);
+      data.set<11>(true);
+      data.set<13>(true);
+      data.set<17>(true);
+      data.set<19>(true);
+      data.set<23>(true);
+      data.set<29>(true);
+      data.set<31>(true);
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_run_time_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_compile_time_position_run_time_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_set_compile_time_position_value_helper()
+    {
+      etl::bitset<64> data;
+
+      data.set<2, true>();
+      data.set<3, true>();
+      data.set<5, true>();
+      data.set<7, true>();
+      data.set<11, true>();
+      data.set<13, true>();
+      data.set<17, true>();
+      data.set<19, true>();
+      data.set<23, true>();
+      data.set<29, true>();
+      data.set<31, true>();
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_set_compile_time_position_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_with_char_string)
+    {
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.set("110001001000110100010101100111001100010010001101000101011001");
 
@@ -985,18 +761,18 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_wchar_t_string_set)
+    TEST(test_set_with_wchar_t_string)
     {
-      std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.set(L"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1005,18 +781,18 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char16_t_string_set)
+    TEST(test_set_with_char16_t_string)
     {
-      std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.set(u"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1025,18 +801,18 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char32_t_string_set)
+    TEST(test_set_with_char32_t_string)
     {
-      std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.set(U"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1045,10 +821,58 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char_string)
+    TEST(test_set_from_char_nullptr)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
+      const char* s = nullptr;
+
       etl::bitset<60> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char32_t_nullptr)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char)
+    {
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.from_string("110001001000110100010101100111001100010010001101000101011001");
 
@@ -1065,10 +889,10 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_wchar_t_string)
+    TEST(test_from_string_with_wchar_t)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.from_string(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1085,10 +909,10 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char16_t_6string)
+    TEST(test_from_string_with_char16_t)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.from_string(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1105,10 +929,10 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char32_t_string)
+    TEST(test_from_string_with_char32_t)
     {
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<60> data;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64> data;
 
       data.from_string(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1124,6 +948,90 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_from_string_with_char_nullptr)
+    {
+      const char* s = nullptr;
+
+      etl::bitset<60> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char32_t_nullptr)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset<60> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_value_u8_min)
+    {
+      ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits<uint8_t>::min);
+      ETL_CONSTEXPR14 uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_u8_max)
+    {
+      ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits<uint8_t>::max);
+      ETL_CONSTEXPR14 uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_s8_min)
+    {
+      ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits<int8_t>::min);
+      ETL_CONSTEXPR14 int8_t value = data.value<int8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<int8_t>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_s8_max)
+    {
+      ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits<int8_t>::max);
+      ETL_CONSTEXPR14 int8_t value = data.value<int8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<int8_t>::max(), value);
+    }
+
     //*************************************************************************
     TEST(test_value_u16_min)
     {
@@ -1163,19 +1071,19 @@ namespace
     //*************************************************************************
     TEST(test_value_u32_min)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits<uint32_t>::min);
-      ETL_CONSTEXPR14 uint32_t value = data.value<uint32_t>();
+      ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits<int32_t>::min);
+      ETL_CONSTEXPR14 int32_t value = data.value<int32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<uint32_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<int32_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u32_max)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits<uint32_t>::max);
-      ETL_CONSTEXPR14 uint32_t value = data.value<uint32_t>();
+      ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits<int32_t>::max);
+      ETL_CONSTEXPR14 int32_t value = data.value<int32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<uint32_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<int32_t>::max(), value);
     }
 
     //*************************************************************************
@@ -1199,26 +1107,26 @@ namespace
     //*************************************************************************
     TEST(test_value_u64_min)
     {
-      ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<uint64_t>::min);
-      ETL_CONSTEXPR14 uint64_t value = data.value<uint64_t>();
+      ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::min);
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<uint64_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u64_max)
     {
-      ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<uint64_t>::max);
-      ETL_CONSTEXPR14 uint64_t value = data.value<uint64_t>();
+      ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::max);
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<uint64_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s64_min)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::min);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
     }
@@ -1227,16 +1135,66 @@ namespace
     TEST(test_value_s64_max)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::max);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
     }
 
+    //*************************************************************************
+    TEST(test_to_ulong_min)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long>::bits> data(etl::integral_limits<unsigned long>::min);
+      unsigned long value = data.to_ulong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ulong_max)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long>::bits> data(etl::integral_limits<unsigned long>::max);
+      unsigned long value = data.to_ulong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ulong_overflow)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long>::bits + 1> data(etl::integral_limits<unsigned long>::min);
+      CHECK_THROW(data.to_ulong(), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_min)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long long>::bits> data(etl::integral_limits<unsigned long long>::min);
+      unsigned long long value = data.to_ullong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_max)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long long>::bits> data(etl::integral_limits<unsigned long long>::max);
+      unsigned long long value = data.to_ullong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long long>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_overflow)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long long>::bits + 1> data(etl::integral_limits<unsigned long long>::min);
+      CHECK_THROW(data.to_ullong(), etl::bitset_overflow);
+    }
+
     //*************************************************************************
     TEST(test_position_set)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      etl::bitset<64> data;
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1265,13 +1223,20 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_reset_helper()
+    {
+      etl::bitset<64> data(0xFFFFFFFFFFFFFFFULL);
+      data.reset();
+
+      return data;
+    }
+
     TEST(test_reset)
     {
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL);
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_reset_helper());
 
       compare.reset();
-      data.reset();
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -1286,21 +1251,27 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_position_reset_helper()
+    {
+      etl::bitset<64> data(0xFFFFFFFFFFFFFFFULL);
+      data.reset(1);
+      data.reset(3);
+      data.reset(7);
+      data.reset(13);
+
+      return data;
+    }
+
     TEST(test_position_reset)
     {
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL);
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_position_reset_helper());
 
       compare.reset(1);
       compare.reset(3);
       compare.reset(7);
       compare.reset(13);
 
-      data.reset(1);
-      data.reset(3);
-      data.reset(7);
-      data.reset(13);
-
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
       CHECK_EQUAL(compare.none(), data.none());
@@ -1340,8 +1311,8 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_read)
     {
-      ETL_CONSTEXPR14 std::bitset<60> compare(0x3123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data(0x3123456731234567ULL);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0x3123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data(0x3123456731234567ULL);
 
       ETL_CONSTEXPR14 bool bc0 = compare[1U];
       ETL_CONSTEXPR14 bool bd0 = data[1U];
@@ -1361,15 +1332,22 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_index_operator_write)
+    ETL_CONSTEXPR14 etl::bitset<64> test_index_operator_write_helper()
     {
-      etl::bitset<60> data;
+      etl::bitset<64> data;
 
       data[1U] = true;
       data[3U] = true;
       data[7U] = true;
       data[13U] = true;
 
+      return data;
+    }
+
+    TEST(test_index_operator_write)
+    {
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_index_operator_write_helper());
+
       CHECK(data[1U]);
       CHECK(data[3U]);
       CHECK(data[7U]);
@@ -1379,10 +1357,10 @@ namespace
     //*************************************************************************
     TEST(test_any)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.any();
       ETL_CONSTEXPR14 bool bd2 = data2.any();
@@ -1398,10 +1376,10 @@ namespace
     //*************************************************************************
     TEST(test_none)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.none();
       ETL_CONSTEXPR14 bool bd2 = data2.none();
@@ -1417,10 +1395,10 @@ namespace
     //*************************************************************************
     TEST(test_all)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.all();
       ETL_CONSTEXPR14 bool bd2 = data2.all();
@@ -1434,13 +1412,77 @@ namespace
     }
 
     //*************************************************************************
+    TEST(test_any_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.any();
+      ETL_CONSTEXPR14 bool bd2 = data2.any();
+      ETL_CONSTEXPR14 bool bd3 = data3.any();
+      ETL_CONSTEXPR14 bool bd4 = data4.any();
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.none();
+      ETL_CONSTEXPR14 bool bd2 = data2.none();
+      ETL_CONSTEXPR14 bool bd3 = data3.none();
+      ETL_CONSTEXPR14 bool bd4 = data4.none();
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.all();
+      ETL_CONSTEXPR14 bool bd2 = data2.all();
+      ETL_CONSTEXPR14 bool bd3 = data3.all();
+      ETL_CONSTEXPR14 bool bd4 = data4.all();
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_flip_helper()
+    {
+      etl::bitset<64> data;
+      data.flip();
+
+      return data;
+    }
+
     TEST(test_flip)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_flip_helper());
 
       compare.flip();
-      data.flip();
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1449,21 +1491,27 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_flip_position_helper()
+    {
+      etl::bitset<64> data;
+      data.flip(1);
+      data.flip(3);
+      data.flip(7);
+      data.flip(13);
+
+      return data;
+    }
+
     TEST(test_flip_position)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_flip_position_helper());
 
       compare.flip(1);
       compare.flip(3);
       compare.flip(7);
       compare.flip(13);
 
-      data.flip(1);
-      data.flip(3);
-      data.flip(7);
-      data.flip(13);
-
       for (size_t i = 0UL; i < data.size(); ++i)
       {
         CHECK_EQUAL(compare.test(i), data.test(i));
@@ -1471,21 +1519,27 @@ namespace
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_flip_reference_helper()
+    {
+      etl::bitset<64> data;
+      data[1].flip();
+      data[3].flip();
+      data[7].flip();
+      data[13].flip();
+
+      return data;
+    }
+
     TEST(test_flip_reference)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64> data(test_flip_reference_helper());
 
       compare[1].flip();
       compare[3].flip();
       compare[7].flip();
       compare[13].flip();
 
-      data[1].flip();
-      data[3].flip();
-      data[7].flip();
-      data[13].flip();
-
       for (size_t i = 0UL; i < data.size(); ++i)
       {
         CHECK_EQUAL(compare.test(i), data.test(i));
@@ -1495,8 +1549,8 @@ namespace
     //*************************************************************************
     TEST(test_invert_reference)
     {
-      std::bitset<60> compare;
-      etl::bitset<60> data;
+      std::bitset<64> compare;
+      etl::bitset<64> data;
 
       bool bc = ~compare[3];
       bool bd = ~data[3];
@@ -1504,18 +1558,18 @@ namespace
     }
 
     //*************************************************************************
-    void test_assignment_operator_helper(etl::bitset<60>& from, etl::bitset<60>& to)
+    ETL_CONSTEXPR14 etl::bitset<64> test_assignment_operator_helper(etl::bitset<64> to, const etl::bitset<64>&from)
     {
       to = from;
+
+      return to;
     }
 
     TEST(test_assignment_operator)
     {
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset<60> data1(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset<60> data2;
-
-      test_assignment_operator_helper(data1, data2);
+      ETL_CONSTEXPR14 std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(test_assignment_operator_helper(etl::bitset<64>(), data1));
 
       for (size_t i = 0UL; i < data2.size(); ++i)
       {
@@ -1526,11 +1580,11 @@ namespace
     //*************************************************************************
     TEST(test_equality_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data2(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data3;
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data3;
 
-      ETL_CONSTEXPR14 bool equal     =  (data1 == data2);
+      ETL_CONSTEXPR14 bool equal = (data1 == data2);
       ETL_CONSTEXPR14 bool not_equal = !(data1 == data3);
 
       CHECK(equal);
@@ -1540,9 +1594,9 @@ namespace
     //*************************************************************************
     TEST(test_inequality_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> data1(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data2(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> data3;
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> data3;
 
       ETL_CONSTEXPR14 bool equal = !(data1 != data2);
       ETL_CONSTEXPR14 bool not_equal = (data1 != data3);
@@ -1554,139 +1608,138 @@ namespace
     //*************************************************************************
     TEST(test_shift_left_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> shift1(0x2468ACF0ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> shift2(0x48D159E0ULL);
-      ETL_CONSTEXPR14 etl::bitset<60> shift11(0x91A2B3C000ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift1(0x2468ACF0ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift2(0x48D159E0ULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift11(0x91A2B3C000ULL);
 
-      CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 1U) == shift1);
-      CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 2U) == shift2);
-      CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 11U) == shift11);
+      CHECK((generate_shift_left_bitset<64>(0x12345678ULL, 1U)) == shift1);
+      CHECK((generate_shift_left_bitset<64>(0x12345678ULL, 2U)) == shift2);
+      CHECK((generate_shift_left_bitset<64>(0x12345678ULL, 11U)) == shift11);
     }
 
     //*************************************************************************
     TEST(test_shift_left_operator_overflow)
     {
-      ETL_CONSTEXPR14 etl::bitset<31> data(generate_shift_left_bitset<31>(0x7FFFFFFFULL, 1U));
-      ETL_CONSTEXPR14 etl::bitset<31> shifted(0x7FFFFFFEUL);
+      ETL_CONSTEXPR14 etl::bitset<32> data(generate_shift_left_bitset<32>(0x7FFFFFFFULL, 1U));
+      ETL_CONSTEXPR14 etl::bitset<32> shifted(0xFFFFFFFEUL);
 
-      CHECK(data == shifted);
+      CHECK_EQUAL_HEX(shifted.value<uint32_t>(), data.value<uint32_t>());
     }
 
     //*************************************************************************
     TEST(test_shift_left_copy_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> shift8(0x1234567800ULL);
-      CHECK_EQUAL_HEX(shift8.value<uint64_t>(), generate_shift_left_bitset_copy<60>(0x12345678UL, 8U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift8(0x1234567800ULL);
+      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 8U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift16(0x123456780000ULL);
-      CHECK_EQUAL_HEX(shift16.value<uint64_t>(), generate_shift_left_bitset_copy<60>(0x12345678UL, 16U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift16(0x123456780000ULL);
+      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 16U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift24(0x12345678000000ULL);
-      CHECK_EQUAL_HEX(shift24.value<uint64_t>(), generate_shift_left_bitset_copy<60>(0x12345678UL, 24U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift24(0x12345678000000ULL);
+      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 24U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift60(0x0000000000000000ULL);
-      CHECK_EQUAL_HEX(shift60.value<uint64_t>(), generate_shift_left_bitset_copy<60>(0x12345678UL, 60U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift64(0x0000000000000000ULL);
+      CHECK_EQUAL_HEX(shift64.value<int64_t>(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
-    TEST(test_shift_left_operator_all_shifts_partial_size)
+    TEST(test_shift_left_operator_all_shifts_full_size)
     {
       uint64_t value = 0x0123456789ABCDEFULL;
-      uint64_t mask  = 0x0FFFFFFFFFFFFFFFULL;
 
-      CHECK_EQUAL_HEX((value << 0U) & mask, (generate_shift_left_bitset<60>(value, 0U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 1U) & mask, (generate_shift_left_bitset<60>(value, 1U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 2U) & mask, (generate_shift_left_bitset<60>(value, 2U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 3U) & mask, (generate_shift_left_bitset<60>(value, 3U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 4U) & mask, (generate_shift_left_bitset<60>(value, 4U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 5U) & mask, (generate_shift_left_bitset<60>(value, 5U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 6U) & mask, (generate_shift_left_bitset<60>(value, 6U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 7U) & mask, (generate_shift_left_bitset<60>(value, 7U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 8U) & mask, (generate_shift_left_bitset<60>(value, 8U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 9U) & mask, (generate_shift_left_bitset<60>(value, 9U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 10U) & mask, (generate_shift_left_bitset<60>(value, 10U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 11U) & mask, (generate_shift_left_bitset<60>(value, 11U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 12U) & mask, (generate_shift_left_bitset<60>(value, 12U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 13U) & mask, (generate_shift_left_bitset<60>(value, 13U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 14U) & mask, (generate_shift_left_bitset<60>(value, 14U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 15U) & mask, (generate_shift_left_bitset<60>(value, 15U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 16U) & mask, (generate_shift_left_bitset<60>(value, 16U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 17U) & mask, (generate_shift_left_bitset<60>(value, 17U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 18U) & mask, (generate_shift_left_bitset<60>(value, 18U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 19U) & mask, (generate_shift_left_bitset<60>(value, 19U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 20U) & mask, (generate_shift_left_bitset<60>(value, 20U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 21U) & mask, (generate_shift_left_bitset<60>(value, 21U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 22U) & mask, (generate_shift_left_bitset<60>(value, 22U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 23U) & mask, (generate_shift_left_bitset<60>(value, 23U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 24U) & mask, (generate_shift_left_bitset<60>(value, 24U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 25U) & mask, (generate_shift_left_bitset<60>(value, 25U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 26U) & mask, (generate_shift_left_bitset<60>(value, 26U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 27U) & mask, (generate_shift_left_bitset<60>(value, 27U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 28U) & mask, (generate_shift_left_bitset<60>(value, 28U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 29U) & mask, (generate_shift_left_bitset<60>(value, 29U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 30U) & mask, (generate_shift_left_bitset<60>(value, 30U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 31U) & mask, (generate_shift_left_bitset<60>(value, 31U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 32U) & mask, (generate_shift_left_bitset<60>(value, 32U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 33U) & mask, (generate_shift_left_bitset<60>(value, 33U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 34U) & mask, (generate_shift_left_bitset<60>(value, 34U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 35U) & mask, (generate_shift_left_bitset<60>(value, 35U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 36U) & mask, (generate_shift_left_bitset<60>(value, 36U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 37U) & mask, (generate_shift_left_bitset<60>(value, 37U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 38U) & mask, (generate_shift_left_bitset<60>(value, 38U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 39U) & mask, (generate_shift_left_bitset<60>(value, 39U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 40U) & mask, (generate_shift_left_bitset<60>(value, 40U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 41U) & mask, (generate_shift_left_bitset<60>(value, 41U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 42U) & mask, (generate_shift_left_bitset<60>(value, 42U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 43U) & mask, (generate_shift_left_bitset<60>(value, 43U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 44U) & mask, (generate_shift_left_bitset<60>(value, 44U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 45U) & mask, (generate_shift_left_bitset<60>(value, 45U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 46U) & mask, (generate_shift_left_bitset<60>(value, 46U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 47U) & mask, (generate_shift_left_bitset<60>(value, 47U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 48U) & mask, (generate_shift_left_bitset<60>(value, 48U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 49U) & mask, (generate_shift_left_bitset<60>(value, 49U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 50U) & mask, (generate_shift_left_bitset<60>(value, 50U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 51U) & mask, (generate_shift_left_bitset<60>(value, 51U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 52U) & mask, (generate_shift_left_bitset<60>(value, 52U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 53U) & mask, (generate_shift_left_bitset<60>(value, 53U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 54U) & mask, (generate_shift_left_bitset<60>(value, 54U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 55U) & mask, (generate_shift_left_bitset<60>(value, 55U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 56U) & mask, (generate_shift_left_bitset<60>(value, 56U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 57U) & mask, (generate_shift_left_bitset<60>(value, 57U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 58U) & mask, (generate_shift_left_bitset<60>(value, 58U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 59U) & mask, (generate_shift_left_bitset<60>(value, 59U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 60U) & mask, (generate_shift_left_bitset<60>(value, 60U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 61U) & mask, (generate_shift_left_bitset<60>(value, 61U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 62U) & mask, (generate_shift_left_bitset<60>(value, 62U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value << 63U) & mask, (generate_shift_left_bitset<60>(value, 63U).value<uint64_t>()));
-      CHECK_EQUAL_HEX(0ULL,                  (generate_shift_left_bitset<60>(value, 64U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 0U), (generate_shift_left_bitset<64>(value, 0U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 1U), (generate_shift_left_bitset<64>(value, 1U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 2U), (generate_shift_left_bitset<64>(value, 2U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 3U), (generate_shift_left_bitset<64>(value, 3U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 4U), (generate_shift_left_bitset<64>(value, 4U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 5U), (generate_shift_left_bitset<64>(value, 5U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 6U), (generate_shift_left_bitset<64>(value, 6U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 7U), (generate_shift_left_bitset<64>(value, 7U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 8U), (generate_shift_left_bitset<64>(value, 8U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 9U), (generate_shift_left_bitset<64>(value, 9U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 10U), (generate_shift_left_bitset<64>(value, 10U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 11U), (generate_shift_left_bitset<64>(value, 11U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 12U), (generate_shift_left_bitset<64>(value, 12U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 13U), (generate_shift_left_bitset<64>(value, 13U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 14U), (generate_shift_left_bitset<64>(value, 14U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 15U), (generate_shift_left_bitset<64>(value, 15U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 16U), (generate_shift_left_bitset<64>(value, 16U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 17U), (generate_shift_left_bitset<64>(value, 17U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 18U), (generate_shift_left_bitset<64>(value, 18U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 19U), (generate_shift_left_bitset<64>(value, 19U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 20U), (generate_shift_left_bitset<64>(value, 20U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 21U), (generate_shift_left_bitset<64>(value, 21U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 22U), (generate_shift_left_bitset<64>(value, 22U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 23U), (generate_shift_left_bitset<64>(value, 23U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 24U), (generate_shift_left_bitset<64>(value, 24U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 25U), (generate_shift_left_bitset<64>(value, 25U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 26U), (generate_shift_left_bitset<64>(value, 26U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 27U), (generate_shift_left_bitset<64>(value, 27U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 28U), (generate_shift_left_bitset<64>(value, 28U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 29U), (generate_shift_left_bitset<64>(value, 29U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 30U), (generate_shift_left_bitset<64>(value, 30U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 31U), (generate_shift_left_bitset<64>(value, 31U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 32U), (generate_shift_left_bitset<64>(value, 32U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 33U), (generate_shift_left_bitset<64>(value, 33U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 34U), (generate_shift_left_bitset<64>(value, 34U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 35U), (generate_shift_left_bitset<64>(value, 35U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 36U), (generate_shift_left_bitset<64>(value, 36U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 37U), (generate_shift_left_bitset<64>(value, 37U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 38U), (generate_shift_left_bitset<64>(value, 38U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 39U), (generate_shift_left_bitset<64>(value, 39U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 40U), (generate_shift_left_bitset<64>(value, 40U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 41U), (generate_shift_left_bitset<64>(value, 41U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 42U), (generate_shift_left_bitset<64>(value, 42U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 43U), (generate_shift_left_bitset<64>(value, 43U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 44U), (generate_shift_left_bitset<64>(value, 44U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 45U), (generate_shift_left_bitset<64>(value, 45U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 46U), (generate_shift_left_bitset<64>(value, 46U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 47U), (generate_shift_left_bitset<64>(value, 47U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 48U), (generate_shift_left_bitset<64>(value, 48U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 49U), (generate_shift_left_bitset<64>(value, 49U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 50U), (generate_shift_left_bitset<64>(value, 50U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 51U), (generate_shift_left_bitset<64>(value, 51U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 52U), (generate_shift_left_bitset<64>(value, 52U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 53U), (generate_shift_left_bitset<64>(value, 53U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 54U), (generate_shift_left_bitset<64>(value, 54U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 55U), (generate_shift_left_bitset<64>(value, 55U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 56U), (generate_shift_left_bitset<64>(value, 56U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 57U), (generate_shift_left_bitset<64>(value, 57U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 58U), (generate_shift_left_bitset<64>(value, 58U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 59U), (generate_shift_left_bitset<64>(value, 59U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 60U), (generate_shift_left_bitset<64>(value, 60U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 61U), (generate_shift_left_bitset<64>(value, 61U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 62U), (generate_shift_left_bitset<64>(value, 62U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value << 63U), (generate_shift_left_bitset<64>(value, 63U).value<uint64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<64>(value, 64U).value<uint64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> shift1(0x91A2B3CULL);
-      ETL_CONSTEXPR14 etl::bitset<60> shift2(0x48D159EULL);
-      ETL_CONSTEXPR14 etl::bitset<60> shift11(0x2468AULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift1(0x91A2B3CULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift2(0x48D159EULL);
+      ETL_CONSTEXPR14 etl::bitset<64> shift11(0x2468AULL);
 
-      CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 1U) == shift1);
-      CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 2U) == shift2);
-      CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 11U) == shift11);
+      CHECK_EQUAL_HEX(shift1.value<int64_t>(), (generate_shift_right_bitset<64>(0x12345678ULL, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift2.value<int64_t>(), (generate_shift_right_bitset<64>(0x12345678ULL, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift11.value<int64_t>(), (generate_shift_right_bitset<64>(0x12345678ULL, 11U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_copy_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<60> shift8(0x123456ULL);
-      CHECK_EQUAL_HEX(shift8.value<uint64_t>(), generate_shift_right_bitset_copy<60>(0x12345678UL, 8U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift8(0x123456ULL);
+      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 8U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift16(0x1234ULL);
-      CHECK_EQUAL_HEX(shift16.value<uint64_t>(), generate_shift_right_bitset_copy<60>(0x12345678UL, 16U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift16(0x1234ULL);
+      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 16U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift24(0x12ULL);
-      CHECK_EQUAL_HEX(shift24.value<uint64_t>(), generate_shift_right_bitset_copy<60>(0x12345678UL, 24U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift24(0x12ULL);
+      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 24U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<60> shift60(0x00ULL);
-      CHECK_EQUAL_HEX(shift60.value<uint64_t>(), generate_shift_right_bitset_copy<60>(0x12345678UL, 60U).value<uint64_t>());
+      ETL_CONSTEXPR14 etl::bitset<64> shift60(0x00ULL);
+      CHECK_EQUAL_HEX(shift60.value<int64_t>(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 60U).value<int64_t>()));
     }
 
     //*************************************************************************
@@ -1694,331 +1747,335 @@ namespace
     {
       uint64_t value = 0x0123456789ABCDEFULL;
 
-      CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64>(value, 0U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64>(value, 1U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64>(value, 2U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64>(value, 3U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64>(value, 4U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64>(value, 5U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64>(value, 6U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64>(value, 7U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64>(value, 8U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64>(value, 9U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64>(value, 10U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64>(value, 11U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64>(value, 12U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64>(value, 13U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64>(value, 14U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64>(value, 15U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64>(value, 16U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64>(value, 17U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64>(value, 18U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64>(value, 19U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64>(value, 20U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64>(value, 21U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64>(value, 22U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64>(value, 23U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64>(value, 24U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64>(value, 25U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64>(value, 26U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64>(value, 27U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64>(value, 28U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64>(value, 29U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64>(value, 30U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64>(value, 31U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64>(value, 32U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64>(value, 33U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64>(value, 34U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64>(value, 35U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64>(value, 36U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64>(value, 37U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64>(value, 38U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64>(value, 39U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64>(value, 40U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64>(value, 41U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64>(value, 42U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64>(value, 43U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64>(value, 44U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64>(value, 45U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64>(value, 46U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64>(value, 47U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64>(value, 48U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64>(value, 49U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64>(value, 50U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64>(value, 51U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64>(value, 52U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64>(value, 53U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64>(value, 54U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64>(value, 55U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64>(value, 56U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64>(value, 57U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64>(value, 58U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64>(value, 59U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64>(value, 60U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64>(value, 61U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64>(value, 62U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64>(value, 63U).value<uint64_t>()));
-      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64>(value, 0U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64>(value, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64>(value, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64>(value, 3U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64>(value, 4U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64>(value, 5U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64>(value, 6U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64>(value, 7U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64>(value, 8U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64>(value, 9U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64>(value, 10U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64>(value, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64>(value, 12U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64>(value, 13U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64>(value, 14U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64>(value, 15U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64>(value, 16U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64>(value, 17U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64>(value, 18U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64>(value, 19U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64>(value, 20U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64>(value, 21U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64>(value, 22U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64>(value, 23U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64>(value, 24U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64>(value, 25U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64>(value, 26U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64>(value, 27U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64>(value, 28U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64>(value, 29U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64>(value, 30U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64>(value, 31U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64>(value, 32U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64>(value, 33U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64>(value, 34U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64>(value, 35U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64>(value, 36U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64>(value, 37U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64>(value, 38U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64>(value, 39U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64>(value, 40U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64>(value, 41U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64>(value, 42U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64>(value, 43U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64>(value, 44U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64>(value, 45U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64>(value, 46U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64>(value, 47U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64>(value, 48U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64>(value, 49U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64>(value, 50U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64>(value, 51U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64>(value, 52U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64>(value, 53U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64>(value, 54U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64>(value, 55U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64>(value, 56U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64>(value, 57U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64>(value, 58U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64>(value, 59U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64>(value, 60U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64>(value, 61U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64>(value, 62U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64>(value, 63U).value<int64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator_all_shifts_partial_size)
     {
       uint64_t value = 0x0123456789ABCDEFULL;
-      uint64_t mask  = 0x0FFFFFFFFFFFFFFFULL;
+      uint64_t mask = 0x0FFFFFFFFFFFFFFFULL;
 
-      CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<60>(value, 0U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<60>(value, 1U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<60>(value, 2U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<60>(value, 3U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<60>(value, 4U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<60>(value, 5U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<60>(value, 6U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<60>(value, 7U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<60>(value, 8U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<60>(value, 9U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<60>(value, 10U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<60>(value, 11U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<60>(value, 12U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<60>(value, 13U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<60>(value, 14U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<60>(value, 15U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<60>(value, 16U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<60>(value, 17U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<60>(value, 18U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<60>(value, 19U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<60>(value, 20U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<60>(value, 21U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<60>(value, 22U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<60>(value, 23U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<60>(value, 24U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<60>(value, 25U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<60>(value, 26U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<60>(value, 27U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<60>(value, 28U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<60>(value, 29U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<60>(value, 30U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<60>(value, 31U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<60>(value, 32U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<60>(value, 33U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<60>(value, 34U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<60>(value, 35U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<60>(value, 36U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<60>(value, 37U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<60>(value, 38U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<60>(value, 39U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<60>(value, 40U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<60>(value, 41U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<60>(value, 42U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<60>(value, 43U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<60>(value, 44U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<60>(value, 45U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<60>(value, 46U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<60>(value, 47U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<60>(value, 48U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<60>(value, 49U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<60>(value, 50U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<60>(value, 51U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<60>(value, 52U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<60>(value, 53U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<60>(value, 54U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<60>(value, 55U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<60>(value, 56U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<60>(value, 57U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<60>(value, 58U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<60>(value, 59U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<60>(value, 60U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<60>(value, 61U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<60>(value, 62U).value<uint64_t>()));
-      CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<60>(value, 63U).value<uint64_t>()));
-      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<60>(value, 64U).value<uint64_t>()));
+      CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64>(value, 0U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64>(value, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64>(value, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64>(value, 3U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64>(value, 4U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64>(value, 5U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64>(value, 6U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64>(value, 7U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64>(value, 8U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64>(value, 9U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64>(value, 10U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64>(value, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64>(value, 12U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64>(value, 13U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64>(value, 14U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64>(value, 15U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64>(value, 16U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64>(value, 17U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64>(value, 18U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64>(value, 19U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64>(value, 20U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64>(value, 21U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64>(value, 22U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64>(value, 23U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64>(value, 24U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64>(value, 25U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64>(value, 26U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64>(value, 27U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64>(value, 28U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64>(value, 29U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64>(value, 30U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64>(value, 31U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64>(value, 32U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64>(value, 33U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64>(value, 34U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64>(value, 35U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64>(value, 36U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64>(value, 37U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64>(value, 38U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64>(value, 39U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64>(value, 40U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64>(value, 41U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64>(value, 42U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64>(value, 43U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64>(value, 44U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64>(value, 45U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64>(value, 46U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64>(value, 47U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64>(value, 48U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64>(value, 49U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64>(value, 50U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64>(value, 51U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64>(value, 52U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64>(value, 53U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64>(value, 54U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64>(value, 55U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64>(value, 56U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64>(value, 57U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64>(value, 58U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64>(value, 59U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64>(value, 60U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64>(value, 61U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64>(value, 62U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64>(value, 63U).value<int64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_and_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data3(0x12345678UL & 0x23456789UL);
-      etl::bitset<60> data4(data1 & data2);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data4(0x12345678UL & 0x23456789UL);
+
+      ETL_CONSTEXPR14 etl::bitset<64> data3 = data1 & data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_and_equals_operator_helper(etl::bitset<64> data1, const etl::bitset<64>&data2)
+    {
+      data1 &= data2;
+
+      return data1;
+    }
+
     TEST(test_and_equals_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data3(0x12345678UL & 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
 
-      etl::bitset<60> data4(data1);
-      data4 &= data2;
-      CHECK(data3 == data4);
+      ETL_CONSTEXPR14 etl::bitset<64> data3(test_and_equals_operator_helper(data1, data2));
+
+      CHECK((data1 & data2) == data3);
     }
 
     //*************************************************************************
     TEST(test_or_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data4(0x12345678UL | 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data4(0x12345678UL | 0x23456789UL);
 
-      etl::bitset<60> data3(data1 | data2);
+      ETL_CONSTEXPR14 etl::bitset<64> data3 = data1 | data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_or_equals_operator_helper(etl::bitset<64> data1, const etl::bitset<64>&data2)
+    {
+      data1 |= data2;
+
+      return data1;
+    }
+
     TEST(test_or_equals_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data3(0x12345678UL | 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
 
-      etl::bitset<60> data4(data1);
-      data4 |= data2;
-      CHECK(data3 == data4);
+      ETL_CONSTEXPR14 etl::bitset<64> data3(test_or_equals_operator_helper(data1, data2));
+
+      CHECK((data1 | data2) == data3);
     }
 
     //*************************************************************************
     TEST(test_xor_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data4(0x12345678UL ^ 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data4(0x12345678UL ^ 0x23456789UL);
 
-      etl::bitset<60> data3(data1 ^ data2);
+      ETL_CONSTEXPR14 etl::bitset<64> data3 = data1 ^ data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64> test_xor_equals_operator_helper(etl::bitset<64> data1, const etl::bitset<64>&data2)
+    {
+      data1 ^= data2;
+
+      return data1;
+    }
+
     TEST(test_xor_equals_operator)
     {
-      etl::bitset<60> data1(0x12345678UL);
-      etl::bitset<60> data2(0x23456789UL);
-      etl::bitset<60> data3(0x12345678UL ^ 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL);
 
-      etl::bitset<60> data4(data1);
-      data4 ^= data2;
-      CHECK(data3 == data4);
+      ETL_CONSTEXPR14 etl::bitset<64> data3(test_xor_equals_operator_helper(data1, data2));
+
+      CHECK((data1 ^ data2) == data3);
     }
 
     //*************************************************************************
     TEST(test_find_first)
     {
-      ETL_CONSTEXPR14 etl::bitset<9> bs1(ull(0x0000));
-      ETL_CONSTEXPR14 size_t bs1fff = bs1.find_first(false);
-      ETL_CONSTEXPR14 size_t bs1fft = bs1.find_first(true);
-      CHECK_EQUAL(0U, bs1fff);
-      CHECK_EQUAL(etl::bitset<>::npos, bs1fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs1(ull(0x00));
+      ETL_CONSTEXPR14 size_t bs1find_first_false = bs1.find_first(false);
+      ETL_CONSTEXPR14 size_t bs1find_first_true = bs1.find_first(true);
+      CHECK_EQUAL(0U, bs1find_first_false);
+      CHECK_EQUAL(etl::bitset<>::npos, bs1find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs2(ull(0x01FF));
-      ETL_CONSTEXPR14 size_t bs2fff = bs2.find_first(false);
-      ETL_CONSTEXPR14 size_t bs2fft = bs2.find_first(true);
-      CHECK_EQUAL(etl::bitset<>::npos, bs2fff);
-      CHECK_EQUAL(0U, bs2fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs2(ull(0xFF));
+      ETL_CONSTEXPR14 size_t bs2find_first_false = bs2.find_first(false);
+      ETL_CONSTEXPR14 size_t bs2find_first_true = bs2.find_first(true);
+      CHECK_EQUAL(etl::bitset<>::npos, bs2find_first_false);
+      CHECK_EQUAL(0U, bs2find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs3(ull(0x0001));
-      ETL_CONSTEXPR14 size_t bs3fff = bs3.find_first(false);
-      ETL_CONSTEXPR14 size_t bs3fft = bs3.find_first(true);
-      CHECK_EQUAL(1U, bs3fff);
-      CHECK_EQUAL(0U, bs3fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs3(ull(0x01));
+      ETL_CONSTEXPR14 size_t bs3find_first_false = bs3.find_first(false);
+      ETL_CONSTEXPR14 size_t bs3find_first_true = bs3.find_first(true);
+      CHECK_EQUAL(1U, bs3find_first_false);
+      CHECK_EQUAL(0U, bs3find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs4(ull(0x0020));
-      ETL_CONSTEXPR14 size_t bs4fff = bs4.find_first(false);
-      ETL_CONSTEXPR14 size_t bs4fft = bs4.find_first(true);
-      CHECK_EQUAL(0U, bs4fff);
-      CHECK_EQUAL(5U, bs4fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs4(ull(0x20));
+      ETL_CONSTEXPR14 size_t bs4find_first_false = bs4.find_first(false);
+      ETL_CONSTEXPR14 size_t bs4find_first_true = bs4.find_first(true);
+      CHECK_EQUAL(0U, bs4find_first_false);
+      CHECK_EQUAL(5U, bs4find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs5(ull(0x0021));
-      ETL_CONSTEXPR14 size_t bs5fff = bs5.find_first(false);
-      ETL_CONSTEXPR14 size_t bs5fft = bs5.find_first(true);
-      CHECK_EQUAL(1U, bs5fff);
-      CHECK_EQUAL(0U, bs5fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs5(ull(0x21));
+      ETL_CONSTEXPR14 size_t bs5find_first_false = bs5.find_first(false);
+      ETL_CONSTEXPR14 size_t bs5find_first_true = bs5.find_first(true);
+      CHECK_EQUAL(1U, bs5find_first_false);
+      CHECK_EQUAL(0U, bs5find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs6(ull(0x000E));
-      ETL_CONSTEXPR14 size_t bs6fff = bs6.find_first(false);
-      ETL_CONSTEXPR14 size_t bs6fft = bs6.find_first(true);
-      CHECK_EQUAL(0U, bs6fff);
-      CHECK_EQUAL(1U, bs6fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs6(ull(0x0E));
+      ETL_CONSTEXPR14 size_t bs6find_first_false = bs6.find_first(false);
+      ETL_CONSTEXPR14 size_t bs6find_first_true = bs6.find_first(true);
+      CHECK_EQUAL(0U, bs6find_first_false);
+      CHECK_EQUAL(1U, bs6find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs7(ull(0x31));
-      ETL_CONSTEXPR14 size_t bs7fff = bs7.find_first(false);
-      ETL_CONSTEXPR14 size_t bs7fft = bs7.find_first(true);
-      CHECK_EQUAL(1U, bs7fff);
-      CHECK_EQUAL(0U, bs7fft);
+      ETL_CONSTEXPR14 etl::bitset<8> bs7(ull(0x31));
+      ETL_CONSTEXPR14 size_t bs7find_first_false = bs7.find_first(false);
+      ETL_CONSTEXPR14 size_t bs7find_first_true = bs7.find_first(true);
+      CHECK_EQUAL(1U, bs7find_first_false);
+      CHECK_EQUAL(0U, bs7find_first_true);
     }
-     
+
     //*************************************************************************
     TEST(test_find_next)
     {
-      ETL_CONSTEXPR14 etl::bitset<9> bs1(ull(0x0000));
-      ETL_CONSTEXPR14 size_t bs1fnf0 = bs1.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs1fnf1 = bs1.find_next(false, 1);
-      ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 2);
-      CHECK_EQUAL(0U, bs1fnf0);
-      CHECK_EQUAL(1U, bs1fnf1);
-      CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2);
+      ETL_CONSTEXPR14 etl::bitset<8> bs1(ull(0x00));
+      ETL_CONSTEXPR14 size_t bs1find_next_false0 = bs1.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs1find_next_false1 = bs1.find_next(false, 1);
+      ETL_CONSTEXPR14 size_t bs1find_next_true2 = bs1.find_next(true, 2);
+      CHECK_EQUAL(0U, bs1find_next_false0);
+      CHECK_EQUAL(1U, bs1find_next_false1);
+      CHECK_EQUAL(etl::bitset<>::npos, bs1find_next_true2);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs2(ull(0x1FF));
-      ETL_CONSTEXPR14 size_t bs2fnt0 = bs2.find_next(true, 0);
-      ETL_CONSTEXPR14 size_t bs2fnt1 = bs2.find_next(true, 1);
-      ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 2);
-      CHECK_EQUAL(0U, bs2fnt0);
-      CHECK_EQUAL(1U, bs2fnt1);
-      CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2);
+      ETL_CONSTEXPR14 etl::bitset<8> bs2(ull(0xFF));
+      ETL_CONSTEXPR14 size_t bs2find_next_true0 = bs2.find_next(true, 0);
+      ETL_CONSTEXPR14 size_t bs2find_next_true1 = bs2.find_next(true, 1);
+      ETL_CONSTEXPR14 size_t bs2find_next_false2 = bs2.find_next(false, 2);
+      CHECK_EQUAL(0U, bs2find_next_true0);
+      CHECK_EQUAL(1U, bs2find_next_true1);
+      CHECK_EQUAL(etl::bitset<>::npos, bs2find_next_false2);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs3(ull(0x000E));
-      ETL_CONSTEXPR14 size_t bs3fnf0 = bs3.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs3fnt1 = bs3.find_next(true, 1);
-      ETL_CONSTEXPR14 size_t bs3fnf2 = bs3.find_next(false, 2);
-      CHECK_EQUAL(0U, bs3fnf0);
-      CHECK_EQUAL(1U, bs3fnt1);
-      CHECK_EQUAL(4U, bs3fnf2);
+      ETL_CONSTEXPR14 etl::bitset<8> bs3(ull(0x0E));
+      ETL_CONSTEXPR14 size_t bs3find_next_false0 = bs3.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs3find_next_true1 = bs3.find_next(true, 1);
+      ETL_CONSTEXPR14 size_t bs3find_next_false2 = bs3.find_next(false, 2);
+      CHECK_EQUAL(0U, bs3find_next_false0);
+      CHECK_EQUAL(1U, bs3find_next_true1);
+      CHECK_EQUAL(4U, bs3find_next_false2);
 
-      ETL_CONSTEXPR14 etl::bitset<9> bs4(ull(0x0031));
-      ETL_CONSTEXPR14 size_t bs4fnt0 = bs4.find_next(true, 0);
-      ETL_CONSTEXPR14 size_t bs4fnf0 = bs4.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs4fnt1 = bs4.find_next(true, 1);
-      CHECK_EQUAL(0U, bs4fnt0);
-      CHECK_EQUAL(1U, bs4fnf0);
-      CHECK_EQUAL(4U, bs4fnt1);
+      ETL_CONSTEXPR14 etl::bitset<8> bs4(ull(0x31));
+      ETL_CONSTEXPR14 size_t bs4find_next_true0 = bs4.find_next(true, 0);
+      ETL_CONSTEXPR14 size_t bs4find_next_false0 = bs4.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs4find_next_true1 = bs4.find_next(true, 1);
+      CHECK_EQUAL(0U, bs4find_next_true0);
+      CHECK_EQUAL(1U, bs4find_next_false0);
+      CHECK_EQUAL(4U, bs4find_next_true1);
     }
 
     //*************************************************************************
-    TEST(test_find_next_github_issue_617)
+    ETL_CONSTEXPR14 std::pair<etl::bitset<8>, etl::bitset<8>> test_swap_helper()
     {
-      ETL_CONSTEXPR14 etl::bitset<64> bs1(ull(0xC000000000000031));
-      ETL_CONSTEXPR14 size_t bs1fnt1 = bs1.find_next(true, 10);
-      ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 59);
-      CHECK_EQUAL(62U, bs1fnt1);
-      CHECK_EQUAL(62U, bs1fnt2);
+      etl::bitset<8> data1(ull(0x2A));
+      etl::bitset<8> data2(ull(0x15));
 
-      ETL_CONSTEXPR14 etl::bitset<64> bs2(ull(0x3FFFFFFFFFFFFFCE));
-      ETL_CONSTEXPR14 size_t bs2fnf1 = bs2.find_next(false, 10);
-      ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 59);
-      CHECK_EQUAL(62U, bs2fnf1);
-      CHECK_EQUAL(62U, bs2fnf2);
+      swap(data1, data2);
 
-      ETL_CONSTEXPR14 etl::bitset<64, uint32_t> bs32(ull(0xC000000000000031));
-      ETL_CONSTEXPR14 size_t bs32fnt1 = bs32.find_next(true, 10);
-      ETL_CONSTEXPR14 size_t bs32fnt2 = bs32.find_next(true, 59);
-      CHECK_EQUAL(62U, bs32fnt1);
-      CHECK_EQUAL(62U, bs32fnt2);
+      return std::pair<etl::bitset<8>, etl::bitset<8>>(data1, data2);
     }
 
-    //*************************************************************************
-    //*************************************************************************
     TEST(test_swap)
     {
-      etl::bitset<9> compare1(0x2A);
-      etl::bitset<9> compare2(0x15);
-      etl::bitset<9> compare1a(0x2A);
-      etl::bitset<9> compare2a(0x15);
+      ETL_CONSTEXPR14 etl::bitset<8> compare1(0x2A);
+      ETL_CONSTEXPR14 etl::bitset<8> compare2(0x15);
 
-      swap(compare1a, compare2a);
+      ETL_CONSTEXPR14 std::pair<etl::bitset<8>, etl::bitset<8>> swapped = test_swap_helper();
 
-      CHECK(compare1 == compare2a);
-      CHECK(compare2 == compare1a);
+      CHECK(swapped.first == compare2);
+      CHECK(swapped.second == compare1);
     }
 
     //*************************************************************************
@@ -2029,10 +2086,25 @@ namespace
       etl::bitset<32> b(0x12345678UL);
 
       span_t s = b.span();
-      CHECK_EQUAL(0x78U, s[0]);
-      CHECK_EQUAL(0x56U, s[1]);
-      CHECK_EQUAL(0x34U, s[2]);
-      CHECK_EQUAL(0x12U, s[3]);
+
+      if (etl::endianness::value() == etl::endian::little)
+      {
+        CHECK_EQUAL(0x78UL, s[0]);
+        CHECK_EQUAL(0x56UL, s[1]);
+        CHECK_EQUAL(0x34UL, s[2]);
+        CHECK_EQUAL(0x12UL, s[3]);
+      }
+      else
+      {
+        CHECK_EQUAL(0x78UL, s[3]);
+        CHECK_EQUAL(0x56UL, s[2]);
+        CHECK_EQUAL(0x34UL, s[1]);
+        CHECK_EQUAL(0x12UL, s[0]);
+      }
+
+      s[2] = 0x9AU;
+      uint32_t value = b.value<uint32_t>();
+      CHECK_EQUAL(0x129A5678UL, value);
     }
 
     //*************************************************************************
@@ -2043,28 +2115,44 @@ namespace
       const etl::bitset<32> b(0x12345678UL);
 
       span_t s = b.span();
-      CHECK_EQUAL(0x78U, s[0]);
-      CHECK_EQUAL(0x56U, s[1]);
-      CHECK_EQUAL(0x34U, s[2]);
-      CHECK_EQUAL(0x12U, s[3]);
+
+      if (etl::endianness::value() == etl::endian::little)
+      {
+        CHECK_EQUAL(0x78UL, s[0]);
+        CHECK_EQUAL(0x56UL, s[1]);
+        CHECK_EQUAL(0x34UL, s[2]);
+        CHECK_EQUAL(0x12UL, s[3]);
+      }
+      else
+      {
+        CHECK_EQUAL(0x78UL, s[3]);
+        CHECK_EQUAL(0x56UL, s[2]);
+        CHECK_EQUAL(0x34UL, s[1]);
+        CHECK_EQUAL(0x12UL, s[0]);
+      }
     }
 
     //*************************************************************************
     TEST(test_to_string)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+      using bs32 = etl::bitset<32>;
+
+      ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
       etl::string<32> text = b.to_string('.', '*');
-      std::string stdtext  = b.to_string<std::string>('.', '*');
+      std::string stdtext = b.to_string<std::string>('.', '*');
 
-      CHECK_EQUAL("...*..*...**.*...*.*.**..****...", text.c_str());
-      CHECK_EQUAL("...*..*...**.*...*.*.**..****...", stdtext.c_str());
+      //CHECK_THROW(b.to_string<etl::string<30>>('.', '*'), etl::bitset_overflow);
+      CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(text.c_str()));
+      CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(stdtext.c_str()));
     }
 
     //*************************************************************************
     TEST(test_to_wstring)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+      using bs32 = etl::bitset<32>;
+
+      ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
       etl::wstring<32> text = b.to_string<etl::wstring<32>>(L'.', L'*');
       std::wstring stdtext = b.to_string<std::wstring>(L'.', L'*');
@@ -2076,7 +2164,9 @@ namespace
     //*************************************************************************
     TEST(test_to_u16string)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+      using bs32 = etl::bitset<32>;
+
+      ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
       etl::u16string<32> text = b.to_string<etl::u16string<32>>(u'.', u'*');
       std::u16string stdtext = b.to_string<std::u16string>(u'.', u'*');
@@ -2088,7 +2178,9 @@ namespace
     //*************************************************************************
     TEST(test_to_u32string)
     {
-      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+      using bs32 = etl::bitset<32>;
+
+      ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
       etl::u32string<32> text = b.to_string<etl::u32string<32>>(U'.', U'*');
       std::u32string stdtext = b.to_string<std::u32string>(U'.', U'*');
@@ -2096,5 +2188,521 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    ////*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>(0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>(1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>(2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>(3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>(4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>(5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>(6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>(7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>(8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>(9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>(0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>(1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>(2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>(3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>(4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>(5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>(6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>(7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>(8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>(9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t, 0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t, 2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t, 3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t, 4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t, 5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t, 6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t, 7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t, 8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>(0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>(1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>(2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>(3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>(4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>(5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>(6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>(7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>(8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>(9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t, 0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t, 1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t, 2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t, 3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t, 4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t, 5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t, 6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t, 7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t, 8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t, 9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>(0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>(1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>(3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>(4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>(5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>(6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>(7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>(8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t, 0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t, 1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t, 3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t, 4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t, 5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t, 6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t, 7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t, 8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>(0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>(1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>(3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>(4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>(5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>(6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>(7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>(8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>(0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>(1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>(2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>(3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>(4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>(5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>(6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>(7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>(8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>(9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t, 9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
+    }
+
+    //*************************************************************************
+    bool test_bit(int i)
+    {
+      return (0x1234 & (1 << i)) != 0;
+    }
+
+    TEST(test_test_run_time)
+    {
+      ETL_CONSTEXPR14 etl::bitset<16> b(0x1234);
+
+      ETL_CONSTEXPR14 bool t0 = b.test(0);
+      ETL_CONSTEXPR14 bool t1 = b.test(1);
+      ETL_CONSTEXPR14 bool t2 = b.test(2);
+      ETL_CONSTEXPR14 bool t3 = b.test(3);
+      ETL_CONSTEXPR14 bool t4 = b.test(4);
+      ETL_CONSTEXPR14 bool t5 = b.test(5);
+      ETL_CONSTEXPR14 bool t6 = b.test(6);
+      ETL_CONSTEXPR14 bool t7 = b.test(7);
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
+
+    //*************************************************************************
+    TEST(test_test_compile_time)
+    {
+      ETL_CONSTEXPR14 etl::bitset<16> b(0x1234);
+
+      ETL_CONSTEXPR14 bool t0 = b.test<0>();
+      ETL_CONSTEXPR14 bool t1 = b.test<1>();
+      ETL_CONSTEXPR14 bool t2 = b.test<2>();
+      ETL_CONSTEXPR14 bool t3 = b.test<3>();
+      ETL_CONSTEXPR14 bool t4 = b.test<4>();
+      ETL_CONSTEXPR14 bool t5 = b.test<5>();
+      ETL_CONSTEXPR14 bool t6 = b.test<6>();
+      ETL_CONSTEXPR14 bool t7 = b.test<7>();
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
   };
 }
diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp
index b9c0c84b..2fa756a3 100644
--- a/test/test_bitset_new_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_explicit_single_element_type.cpp
@@ -117,13 +117,84 @@ namespace
     return data2;
   }
 
-  SUITE(test_bitset_new_implicit_element_type)
+  SUITE(test_bitset_new_explicit_element_type)
   {
+    //*************************************************************************
+    TEST(test_constants)
+    {
+      using bitset_type  = etl::bitset<60, uint64_t>;
+      using element_type = bitset_type::element_type;
+
+      constexpr size_t       Size               = 60;
+      constexpr size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
+      constexpr size_t       Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
+      constexpr element_type All_Set_Element    = etl::integral_limits<element_type>::max;
+      constexpr element_type All_Clear_Element  = etl::integral_limits<element_type>::min;
+
+      //*******************************
+      constexpr size_t Size1 = bitset_type::Size;
+      constexpr size_t Size2 = bitset_type::size();
+
+      CHECK_EQUAL(Size, Size1);
+      CHECK_EQUAL(Size, Size2);
+
+      //*******************************
+      constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
+      constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
+
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
+
+      //*******************************
+      constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
+      constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
+
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
+
+      //*******************************
+      constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
+      constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
+
+      CHECK_EQUAL(All_Set_Element, All_Set_Element1);
+      CHECK_EQUAL(All_Set_Element, All_Set_Element2);
+
+      //*******************************
+      constexpr element_type All_Clear_Element1 = bitset_type::All_Clear_Element;
+      constexpr element_type All_Clear_Element2 = bitset_type::all_clear_element();
+
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
+
+      //*******************************
+      constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
+
+      CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
+
+      //*******************************
+      constexpr char Storage_Model1 = bitset_type::Storage_Model;
+      constexpr char Storage_Model2 = bitset_type::storage_model();
+
+      CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model1);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model2);
+
+      etl::bitset_storage_model bsm;
+
+      bsm = etl::bitset_storage_model::Undefined;
+      CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Single;
+      CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Multi;
+      CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
+    }
+
     //*************************************************************************
     TEST(test_default_constructor)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data;
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -137,22 +208,32 @@ namespace
     //*************************************************************************
     TEST(test_default_constructor_single_element)
     {
-      etl::bitset<8,  int8_t>  data8;
-      etl::bitset<16, int16_t> data16;
-      etl::bitset<32, int32_t> data32;
-      etl::bitset<64, int64_t> data64;
+      etl::bitset<8,  uint8_t>  data8;
+      etl::bitset<16, uint16_t> data16;
+      etl::bitset<32, uint32_t> data32;
+      etl::bitset<64, uint64_t> data64;
+
+      CHECK_EQUAL(8,  data8.Size);
+      CHECK_EQUAL(16, data16.Size);
+      CHECK_EQUAL(32, data32.Size);
+      CHECK_EQUAL(64, data64.Size);
 
       CHECK_EQUAL(1U, data8.Number_Of_Elements);
       CHECK_EQUAL(1U, data16.Number_Of_Elements);
       CHECK_EQUAL(1U, data32.Number_Of_Elements);
       CHECK_EQUAL(1U, data64.Number_Of_Elements);
+
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data8.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data16.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data32.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data64.Storage_Model);
     }
 
     //*************************************************************************
     TEST(test_construct_from_value)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x123456731234567ULL);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -168,10 +249,10 @@ namespace
     TEST(test_copy_construct)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data_copy(data);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data_copy(data);
 
-      CHECK_EQUAL(compare.size(), data_copy.size());
+      CHECK_EQUAL(compare.size(),  data_copy.size());
       CHECK_EQUAL(compare.count(), data_copy.count());
 
       for (size_t i = 0UL; i < data_copy.size(); ++i)
@@ -184,7 +265,7 @@ namespace
     TEST(test_construct_from_excess_value)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0x8765432187654321ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x8765432187654321ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x8765432187654321ULL);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -199,7 +280,7 @@ namespace
     TEST(test_construct_from_char_string)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001");
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -214,9 +295,9 @@ namespace
     TEST(test_construct_from_wchar_t_string)
     {
       std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64, uint64_t> data(L"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -229,9 +310,9 @@ namespace
     TEST(test_construct_from_char16_t_string)
     {
       std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64, uint64_t> data(u"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -244,9 +325,9 @@ namespace
     TEST(test_construct_from_char32_t_string)
     {
       std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset<64, uint64_t> data(U"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -255,11 +336,55 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char_string)
+    {
+      const char* s = nullptr;
+
+      etl::bitset<60, uint64_t> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_wchar_t_string)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset<60, uint64_t> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char16_t_string)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset<60, uint64_t> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char32_t_string)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset<60, uint64_t> data(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
     //*************************************************************************
     TEST(test_construct_from_excess_string)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001");
-      etl::bitset<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001111100001");
+      etl::bitset<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001111100001");
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -276,9 +401,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_set_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_helper()
     {
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
       data.set();
 
       return data;
@@ -287,7 +412,7 @@ namespace
     TEST(test_set)
     {
       std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_set_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_helper());
 
       compare.set();
 
@@ -310,10 +435,312 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char_string_set)
+    TEST(test_set_less_than_full_size)
+    {
+      std::bitset<60> compare;
+      etl::bitset<60, uint64_t> data;
+
+      compare.set();
+      data.set();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_run_time_position_default_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set(2);
+      data.set(3);
+      data.set(5);
+      data.set(7);
+      data.set(11);
+      data.set(13);
+      data.set(17);
+      data.set(19);
+      data.set(23);
+      data.set(29);
+      data.set(31);
+
+      return data;
+    }
+
+    TEST(test_set_run_time_position_default_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_run_time_position_default_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_run_time_position_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set(2, true);
+      data.set(3, true);
+      data.set(5, true);
+      data.set(7, true);
+      data.set(11, true);
+      data.set(13, true);
+      data.set(17, true);
+      data.set(19, true);
+      data.set(23, true);
+      data.set(29, true);
+      data.set(31, true);
+
+      return data;
+    }
+
+    TEST(test_set_run_time_position_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_run_time_position_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_compile_time_position_run_time_default_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set<2>();
+      data.set<3>();
+      data.set<5>();
+      data.set<7>();
+      data.set<11>();
+      data.set<13>();
+      data.set<17>();
+      data.set<19>();
+      data.set<23>();
+      data.set<29>();
+      data.set<31>();
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_run_time_default_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_compile_time_position_run_time_default_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_compile_time_position_run_time_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set<2>(true);
+      data.set<3>(true);
+      data.set<5>(true);
+      data.set<7>(true);
+      data.set<11>(true);
+      data.set<13>(true);
+      data.set<17>(true);
+      data.set<19>(true);
+      data.set<23>(true);
+      data.set<29>(true);
+      data.set<31>(true);
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_run_time_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_compile_time_position_run_time_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_compile_time_position_value_helper()
+    {
+      etl::bitset<64, uint64_t> data;
+
+      data.set<2, true>();
+      data.set<3, true>();
+      data.set<5, true>();
+      data.set<7, true>();
+      data.set<11, true>();
+      data.set<13, true>();
+      data.set<17, true>();
+      data.set<19, true>();
+      data.set<23, true>();
+      data.set<29, true>();
+      data.set<31, true>();
+
+      return data;
+    }
+
+    TEST(test_set_compile_time_position_value)
+    {
+      std::bitset<64> compare;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_compile_time_position_value_helper());
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      ETL_CONSTEXPR14 auto size  = data.size();
+      ETL_CONSTEXPR14 auto count = data.count();
+      ETL_CONSTEXPR14 auto none  = data.none();
+      ETL_CONSTEXPR14 auto any   = data.any();
+      ETL_CONSTEXPR14 auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_with_char_string)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.set("110001001000110100010101100111001100010010001101000101011001");
 
@@ -330,18 +757,18 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_wchar_t_string_set)
+    TEST(test_set_with_wchar_t_string)
     {
       std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.set(L"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -350,18 +777,18 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char16_t_string_set)
+    TEST(test_set_with_char16_t_string)
     {
       std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.set(u"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -370,18 +797,18 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char32_t_string_set)
+    TEST(test_set_with_char32_t_string)
     {
       std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.set(U"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -390,18 +817,66 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char_string)
+    TEST(test_set_from_char_nullptr)
+    {
+      const char* s = nullptr;
+
+      etl::bitset<60, uint64_t> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset<60, uint64_t> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset<60, uint64_t> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char32_t_nullptr)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset<60, uint64_t> data;
+      data.set(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.from_string("110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -410,18 +885,18 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_wchar_t_string)
+    TEST(test_from_string_with_wchar_t)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.from_string(L"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -430,18 +905,18 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char16_t_6string)
+    TEST(test_from_string_with_char16_t)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.from_string(u"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -450,18 +925,18 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char32_t_string)
+    TEST(test_from_string_with_char32_t)
     {
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data.from_string(U"110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(), data.none());
-      CHECK_EQUAL(compare.any(), data.any());
-      CHECK_EQUAL(compare.all(), data.all());
+      CHECK_EQUAL(compare.none(),  data.none());
+      CHECK_EQUAL(compare.any(),   data.any());
+      CHECK_EQUAL(compare.all(),   data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -469,6 +944,54 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_from_string_with_char_nullptr)
+    {
+      const char* s = nullptr;
+
+      etl::bitset<60, uint64_t> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset<60, uint64_t> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset<60, uint64_t> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char32_t_nullptr)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset<60, uint64_t> data;
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0,  data.count());
+    }
+
     //*************************************************************************
     TEST(test_value_u8_min)
     {
@@ -581,7 +1104,7 @@ namespace
     TEST(test_value_u64_min)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::min);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
     }
@@ -590,7 +1113,7 @@ namespace
     TEST(test_value_u64_max)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::max);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
     }
@@ -599,7 +1122,7 @@ namespace
     TEST(test_value_s64_min)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::min);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
     }
@@ -608,16 +1131,66 @@ namespace
     TEST(test_value_s64_max)
     {
       ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits<int64_t>::max);
-      ETL_CONSTEXPR14 int64_t value = data.value<int64_t>();
+      ETL_CONSTEXPR14 uint64_t value = data.value<int64_t>();
 
       CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
     }
 
+    //*************************************************************************
+    TEST(test_to_ulong_min)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long>::bits, uint64_t> data(etl::integral_limits<unsigned long>::min);
+      unsigned long value = data.to_ulong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ulong_max)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long>::bits, uint64_t> data(etl::integral_limits<unsigned long>::max);
+      unsigned long value = data.to_ulong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ulong_overflow)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long>::bits + 1, uint64_t> data(etl::integral_limits<unsigned long>::min);
+      CHECK_THROW(data.to_ulong(), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_min)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long long>::bits, uint64_t> data(etl::integral_limits<unsigned long long>::min);
+      unsigned long long value = data.to_ullong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_max)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long long>::bits, uint64_t> data(etl::integral_limits<unsigned long long>::max);
+      unsigned long long value = data.to_ullong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long long>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_overflow)
+    {
+      ETL_CONSTEXPR14 etl::bitset<etl::integral_limits<unsigned long long>::bits + 1, uint64_t> data(etl::integral_limits<unsigned long long>::min);
+      CHECK_THROW(data.to_ullong(), etl::bitset_overflow);
+    }
+
     //*************************************************************************
     TEST(test_position_set)
     {
       std::bitset<64> compare;
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -646,9 +1219,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_reset_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_reset_helper()
     {
-      etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL);
       data.reset();
 
       return data;
@@ -657,7 +1230,7 @@ namespace
     TEST(test_reset)
     {
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_reset_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_reset_helper());
 
       compare.reset();
       
@@ -674,9 +1247,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_position_reset_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_position_reset_helper()
     {
-      etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL);
       data.reset(1);
       data.reset(3);
       data.reset(7);
@@ -688,7 +1261,7 @@ namespace
     TEST(test_position_reset)
     {
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_position_reset_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_position_reset_helper());
 
       compare.reset(1);
       compare.reset(3);
@@ -735,7 +1308,7 @@ namespace
     TEST(test_index_operator_read)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0x3123456731234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x3123456731234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x3123456731234567ULL);
 
       ETL_CONSTEXPR14 bool bc0 = compare[1U];
       ETL_CONSTEXPR14 bool bd0 = data[1U];
@@ -755,9 +1328,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_index_operator_write_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_index_operator_write_helper()
     {
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       data[1U]  = true;
       data[3U]  = true;
@@ -769,7 +1342,7 @@ namespace
 
     TEST(test_index_operator_write)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_index_operator_write_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_index_operator_write_helper());
 
       CHECK(data[1U]);
       CHECK(data[3U]);
@@ -780,10 +1353,10 @@ namespace
     //*************************************************************************
     TEST(test_any)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.any();
       ETL_CONSTEXPR14 bool bd2 = data2.any();
@@ -799,10 +1372,10 @@ namespace
     //*************************************************************************
     TEST(test_any_with_mask)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0xF000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -820,10 +1393,10 @@ namespace
     //*************************************************************************
     TEST(test_none)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.none();
       ETL_CONSTEXPR14 bool bd2 = data2.none();
@@ -839,10 +1412,10 @@ namespace
     //*************************************************************************
     TEST(test_none_with_mask)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0xF000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -860,10 +1433,10 @@ namespace
     //*************************************************************************
     TEST(test_all)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 bool bd1 = data1.all();
       ETL_CONSTEXPR14 bool bd2 = data2.all();
@@ -879,10 +1452,10 @@ namespace
     //*************************************************************************
     TEST(test_all_with_mask)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100));
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0x0FFFFFFFFFFFFFFF));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF));
 
       ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -898,9 +1471,129 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_helper()
+    TEST(test_any_with_reduced_active_bits)
     {
-      etl::bitset<64, int64_t> data;
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.any();
+      ETL_CONSTEXPR14 bool bd2 = data2.any();
+      ETL_CONSTEXPR14 bool bd3 = data3.any();
+      ETL_CONSTEXPR14 bool bd4 = data4.any();
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_any_with_mask_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0xF000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
+
+      ETL_CONSTEXPR14 bool bd1 = data1.any(mask);
+      ETL_CONSTEXPR14 bool bd2 = data2.any(mask);
+      ETL_CONSTEXPR14 bool bd3 = data3.any(mask);
+      ETL_CONSTEXPR14 bool bd4 = data4.any(mask);
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.none();
+      ETL_CONSTEXPR14 bool bd2 = data2.none();
+      ETL_CONSTEXPR14 bool bd3 = data3.none();
+      ETL_CONSTEXPR14 bool bd4 = data4.none();
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_mask_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0xF000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF);
+
+      ETL_CONSTEXPR14 bool bd1 = data1.none(mask);
+      ETL_CONSTEXPR14 bool bd2 = data2.none(mask);
+      ETL_CONSTEXPR14 bool bd3 = data3.none(mask);
+      ETL_CONSTEXPR14 bool bd4 = data4.none(mask);
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 bool bd1 = data1.all();
+      ETL_CONSTEXPR14 bool bd2 = data2.all();
+      ETL_CONSTEXPR14 bool bd3 = data3.all();
+      ETL_CONSTEXPR14 bool bd4 = data4.all();
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_mask_with_reduced_active_bits)
+    {
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100));
+      ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF));
+
+      ETL_CONSTEXPR14 ull mask = ull(0x00FFFFFFFFFFFFFF);
+
+      ETL_CONSTEXPR14 bool bd1 = data1.all(mask);
+      ETL_CONSTEXPR14 bool bd2 = data2.all(mask);
+      ETL_CONSTEXPR14 bool bd3 = data3.all(mask);
+      ETL_CONSTEXPR14 bool bd4 = data4.all(mask);
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_helper()
+    {
+      etl::bitset<64, uint64_t> data;
       data.flip();
 
       return data;
@@ -909,7 +1602,7 @@ namespace
     TEST(test_flip)
     {
       std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_helper());
 
       compare.flip();
 
@@ -920,9 +1613,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_position_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_position_helper()
     {
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
       data.flip(1);
       data.flip(3);
       data.flip(7);
@@ -934,7 +1627,7 @@ namespace
     TEST(test_flip_position)
     {
       std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_position_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_position_helper());
 
       compare.flip(1);
       compare.flip(3);
@@ -948,9 +1641,9 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_reference_helper()
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_reference_helper()
     {
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
       data[1].flip();
       data[3].flip();
       data[7].flip();
@@ -962,7 +1655,7 @@ namespace
     TEST(test_flip_reference)
     {
       std::bitset<64> compare;
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_reference_helper());
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_reference_helper());
 
       compare[1].flip();
       compare[3].flip();
@@ -979,7 +1672,7 @@ namespace
     TEST(test_invert_reference)
     {
       std::bitset<64> compare;
-      etl::bitset<64, int64_t> data;
+      etl::bitset<64, uint64_t> data;
 
       bool bc = ~compare[3];
       bool bd = ~data[3];
@@ -987,7 +1680,7 @@ namespace
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_assignment_operator_helper(etl::bitset<64, int64_t> to, const etl::bitset<64, int64_t>& from)
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_assignment_operator_helper(etl::bitset<64, uint64_t> to, const etl::bitset<64, uint64_t>& from)
     {
       to = from;
 
@@ -997,8 +1690,8 @@ namespace
     TEST(test_assignment_operator)
     {
       ETL_CONSTEXPR14 std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0xFFFFFFFFFFFFFFFULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(test_assignment_operator_helper(etl::bitset<64, int64_t>(), data1));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0xFFFFFFFFFFFFFFFULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(test_assignment_operator_helper(etl::bitset<64, uint64_t>(), data1));
 
       for (size_t i = 0UL; i < data2.size(); ++i)
       {
@@ -1009,9 +1702,9 @@ namespace
     //*************************************************************************
     TEST(test_equality_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3;
 
       ETL_CONSTEXPR14 bool equal     =  (data1 == data2);
       ETL_CONSTEXPR14 bool not_equal = !(data1 == data3);
@@ -1023,9 +1716,9 @@ namespace
     //*************************************************************************
     TEST(test_inequality_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x123456781234567ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3;
 
       ETL_CONSTEXPR14 bool equal = !(data1 != data2);
       ETL_CONSTEXPR14 bool not_equal = (data1 != data3);
@@ -1037,38 +1730,38 @@ namespace
     //*************************************************************************
     TEST(test_shift_left_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x2468ACF0ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159E0ULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x91A2B3C000ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift1(0x2468ACF0ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift2(0x48D159E0ULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift11(0x91A2B3C000ULL);
 
-      CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 1U)) == shift1);
-      CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 2U)) == shift2);
-      CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 11U)) == shift11);
+      CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 1U)) == shift1);
+      CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 2U)) == shift2);
+      CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 11U)) == shift11);
     }
 
     //*************************************************************************
     TEST(test_shift_left_operator_overflow)
     {
-      ETL_CONSTEXPR14 etl::bitset<32, int32_t> data(generate_shift_left_bitset<32, int32_t>(0x7FFFFFFFULL, 1U));
-      ETL_CONSTEXPR14 etl::bitset<32, int32_t> shifted(0xFFFFFFFEUL);
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> data(generate_shift_left_bitset<32, uint32_t>(0x7FFFFFFFULL, 1U));
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> shifted(0xFFFFFFFEUL);
 
-      CHECK_EQUAL_HEX(shifted.value<int32_t>(), data.value<int32_t>());
+      CHECK_EQUAL_HEX(shifted.value<uint32_t>(), data.value<uint32_t>());
     }
 
     //*************************************************************************
     TEST(test_shift_left_copy_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x1234567800ULL);
-      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 8U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift8(0x1234567800ULL);
+      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 8U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x123456780000ULL);
-      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 16U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift16(0x123456780000ULL);
+      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 16U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12345678000000ULL);
-      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 24U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift24(0x12345678000000ULL);
+      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 24U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift64(0x0000000000000000ULL);
-      CHECK_EQUAL_HEX(shift64.value<int64_t>(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 64U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift64(0x0000000000000000ULL);
+      CHECK_EQUAL_HEX(shift64.value<int64_t>(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
@@ -1146,189 +1839,189 @@ namespace
     //*************************************************************************
     TEST(test_shift_right_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x91A2B3CULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159EULL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x2468AULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift1(0x91A2B3CULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift2(0x48D159EULL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift11(0x2468AULL);
 
-      CHECK_EQUAL_HEX(shift1.value<int64_t>(),  (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 1U).value<int64_t>()));
-      CHECK_EQUAL_HEX(shift2.value<int64_t>(),  (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 2U).value<int64_t>()));
-      CHECK_EQUAL_HEX(shift11.value<int64_t>(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift1.value<int64_t>(),  (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift2.value<int64_t>(),  (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX(shift11.value<int64_t>(), (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 11U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_copy_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x123456ULL);
-      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 8U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift8(0x123456ULL);
+      CHECK_EQUAL_HEX(shift8.value<int64_t>(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 8U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x1234ULL);
-      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 16U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift16(0x1234ULL);
+      CHECK_EQUAL_HEX(shift16.value<int64_t>(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 16U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12ULL);
-      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 24U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift24(0x12ULL);
+      CHECK_EQUAL_HEX(shift24.value<int64_t>(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 24U).value<int64_t>()));
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift60(0x00ULL);
-      CHECK_EQUAL_HEX(shift60.value<int64_t>(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 60U).value<int64_t>()));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift60(0x00ULL);
+      CHECK_EQUAL_HEX(shift60.value<int64_t>(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 60U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator_all_shifts_full_size)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
 
-      CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64, int64_t>(value, 0U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64, int64_t>(value, 1U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64, int64_t>(value, 2U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64, int64_t>(value, 3U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64, int64_t>(value, 4U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64, int64_t>(value, 5U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64, int64_t>(value, 6U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64, int64_t>(value, 7U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64, int64_t>(value, 8U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64, int64_t>(value, 9U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64, int64_t>(value, 10U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64, int64_t>(value, 11U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64, int64_t>(value, 12U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64, int64_t>(value, 13U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64, int64_t>(value, 14U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64, int64_t>(value, 15U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64, int64_t>(value, 16U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64, int64_t>(value, 17U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64, int64_t>(value, 18U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64, int64_t>(value, 19U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64, int64_t>(value, 20U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64, int64_t>(value, 21U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64, int64_t>(value, 22U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64, int64_t>(value, 23U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64, int64_t>(value, 24U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64, int64_t>(value, 25U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64, int64_t>(value, 26U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64, int64_t>(value, 27U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64, int64_t>(value, 28U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64, int64_t>(value, 29U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64, int64_t>(value, 30U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64, int64_t>(value, 31U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64, int64_t>(value, 32U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64, int64_t>(value, 33U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64, int64_t>(value, 34U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64, int64_t>(value, 35U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64, int64_t>(value, 36U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64, int64_t>(value, 37U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64, int64_t>(value, 38U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64, int64_t>(value, 39U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64, int64_t>(value, 40U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64, int64_t>(value, 41U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64, int64_t>(value, 42U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64, int64_t>(value, 43U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64, int64_t>(value, 44U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64, int64_t>(value, 45U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64, int64_t>(value, 46U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64, int64_t>(value, 47U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64, int64_t>(value, 48U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64, int64_t>(value, 49U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64, int64_t>(value, 50U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64, int64_t>(value, 51U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64, int64_t>(value, 52U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64, int64_t>(value, 53U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64, int64_t>(value, 54U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64, int64_t>(value, 55U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64, int64_t>(value, 56U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64, int64_t>(value, 57U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64, int64_t>(value, 58U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64, int64_t>(value, 59U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64, int64_t>(value, 60U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64, int64_t>(value, 61U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64, int64_t>(value, 62U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64, int64_t>(value, 63U).value<int64_t>()));
-      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, int64_t>(value, 64U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64, uint64_t>(value, 0U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64, uint64_t>(value, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64, uint64_t>(value, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64, uint64_t>(value, 3U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64, uint64_t>(value, 4U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64, uint64_t>(value, 5U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64, uint64_t>(value, 6U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64, uint64_t>(value, 7U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64, uint64_t>(value, 8U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64, uint64_t>(value, 9U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64, uint64_t>(value, 10U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64, uint64_t>(value, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64, uint64_t>(value, 12U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64, uint64_t>(value, 13U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64, uint64_t>(value, 14U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64, uint64_t>(value, 15U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64, uint64_t>(value, 16U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64, uint64_t>(value, 17U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64, uint64_t>(value, 18U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64, uint64_t>(value, 19U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64, uint64_t>(value, 20U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64, uint64_t>(value, 21U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64, uint64_t>(value, 22U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64, uint64_t>(value, 23U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64, uint64_t>(value, 24U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64, uint64_t>(value, 25U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64, uint64_t>(value, 26U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64, uint64_t>(value, 27U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64, uint64_t>(value, 28U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64, uint64_t>(value, 29U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64, uint64_t>(value, 30U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64, uint64_t>(value, 31U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64, uint64_t>(value, 32U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64, uint64_t>(value, 33U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64, uint64_t>(value, 34U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64, uint64_t>(value, 35U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64, uint64_t>(value, 36U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64, uint64_t>(value, 37U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64, uint64_t>(value, 38U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64, uint64_t>(value, 39U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64, uint64_t>(value, 40U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64, uint64_t>(value, 41U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64, uint64_t>(value, 42U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64, uint64_t>(value, 43U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64, uint64_t>(value, 44U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64, uint64_t>(value, 45U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64, uint64_t>(value, 46U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64, uint64_t>(value, 47U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64, uint64_t>(value, 48U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64, uint64_t>(value, 49U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64, uint64_t>(value, 50U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64, uint64_t>(value, 51U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64, uint64_t>(value, 52U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64, uint64_t>(value, 53U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64, uint64_t>(value, 54U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64, uint64_t>(value, 55U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64, uint64_t>(value, 56U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64, uint64_t>(value, 57U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64, uint64_t>(value, 58U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64, uint64_t>(value, 59U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64, uint64_t>(value, 60U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64, uint64_t>(value, 61U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64, uint64_t>(value, 62U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64, uint64_t>(value, 63U).value<int64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, uint64_t>(value, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator_all_shifts_partial_size)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
-      int64_t mask  = 0x0FFFFFFFFFFFFFFFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
+      uint64_t mask  = 0x0FFFFFFFFFFFFFFFULL;
 
-      CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 0U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 1U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 2U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 3U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 4U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 5U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 6U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 7U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 8U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 9U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 10U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 11U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 12U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 13U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 14U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 15U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 16U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 17U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 18U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 19U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 20U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 21U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 22U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 23U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 24U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 25U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 26U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 27U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 28U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 29U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 30U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 31U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 32U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 33U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 34U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 35U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 36U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 37U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 38U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 39U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 40U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 41U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 42U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 43U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 44U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 45U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 46U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 47U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 48U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 49U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 50U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 51U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 52U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 53U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 54U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 55U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 56U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 57U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 58U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 59U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 60U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 61U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 62U).value<int64_t>()));
-      CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 63U).value<int64_t>()));
-      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, int64_t>(value, 64U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 0U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 1U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 2U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 3U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 4U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 5U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 6U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 7U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 8U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 9U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 10U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 11U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 12U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 13U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 14U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 15U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 16U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 17U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 18U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 19U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 20U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 21U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 22U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 23U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 24U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 25U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 26U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 27U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 28U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 29U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 30U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 31U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 32U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 33U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 34U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 35U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 36U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 37U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 38U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 39U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 40U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 41U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 42U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 43U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 44U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 45U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 46U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 47U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 48U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 49U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 50U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 51U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 52U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 53U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 54U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 55U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 56U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 57U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 58U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 59U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 60U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 61U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 62U).value<int64_t>()));
+      CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 63U).value<int64_t>()));
+      CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, uint64_t>(value, 64U).value<int64_t>()));
     }
 
     //*************************************************************************
     TEST(test_and_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL & 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL & 0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 & data2;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 & data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_and_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2)
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_and_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2)
     {
       data1 &= data2;
 
@@ -1337,10 +2030,10 @@ namespace
     
     TEST(test_and_equals_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
       
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_and_equals_operator_helper(data1, data2));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_and_equals_operator_helper(data1, data2));
 
       CHECK((data1 & data2) == data3);
     }
@@ -1348,16 +2041,16 @@ namespace
     //*************************************************************************
     TEST(test_or_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL | 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL | 0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 | data2;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 | data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_or_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2)
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_or_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2)
     {
       data1 |= data2;
 
@@ -1366,10 +2059,10 @@ namespace
 
     TEST(test_or_equals_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_or_equals_operator_helper(data1, data2));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_or_equals_operator_helper(data1, data2));
 
       CHECK((data1 | data2) == data3);
     }
@@ -1377,16 +2070,16 @@ namespace
     //*************************************************************************
     TEST(test_xor_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL ^ 0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL ^ 0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 ^ data2;
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 ^ data2;
       CHECK(data3 == data4);
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_xor_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2)
+    ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_xor_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2)
     {
       data1 ^= data2;
 
@@ -1395,10 +2088,10 @@ namespace
 
     TEST(test_xor_equals_operator)
     {
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL);
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL);
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL);
 
-      ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_xor_equals_operator_helper(data1, data2));
+      ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_xor_equals_operator_helper(data1, data2));
 
       CHECK((data1 ^ data2) == data3);
     }
@@ -1406,102 +2099,102 @@ namespace
     //*************************************************************************
     TEST(test_find_first)
     {
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00));
-      ETL_CONSTEXPR14 size_t bs1fff = bs1.find_first(false);
-      ETL_CONSTEXPR14 size_t bs1fft = bs1.find_first(true);
-      CHECK_EQUAL(0U, bs1fff);
-      CHECK_EQUAL(etl::bitset<>::npos, bs1fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs1(ull(0x00));
+      ETL_CONSTEXPR14 size_t bs1find_first_false = bs1.find_first(false);
+      ETL_CONSTEXPR14 size_t bs1find_first_true  = bs1.find_first(true);
+      CHECK_EQUAL(0U, bs1find_first_false);
+      CHECK_EQUAL(etl::bitset<>::npos, bs1find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF));
-      ETL_CONSTEXPR14 size_t bs2fff = bs2.find_first(false);
-      ETL_CONSTEXPR14 size_t bs2fft = bs2.find_first(true);
-      CHECK_EQUAL(etl::bitset<>::npos, bs2fff);
-      CHECK_EQUAL(0U, bs2fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs2(ull(0xFF));
+      ETL_CONSTEXPR14 size_t bs2find_first_false = bs2.find_first(false);
+      ETL_CONSTEXPR14 size_t bs2find_first_true  = bs2.find_first(true);
+      CHECK_EQUAL(etl::bitset<>::npos, bs2find_first_false);
+      CHECK_EQUAL(0U, bs2find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x01));
-      ETL_CONSTEXPR14 size_t bs3fff = bs3.find_first(false);
-      ETL_CONSTEXPR14 size_t bs3fft = bs3.find_first(true);
-      CHECK_EQUAL(1U, bs3fff);
-      CHECK_EQUAL(0U, bs3fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs3(ull(0x01));
+      ETL_CONSTEXPR14 size_t bs3find_first_false = bs3.find_first(false);
+      ETL_CONSTEXPR14 size_t bs3find_first_true  = bs3.find_first(true);
+      CHECK_EQUAL(1U, bs3find_first_false);
+      CHECK_EQUAL(0U, bs3find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x20));
-      ETL_CONSTEXPR14 size_t bs4fff = bs4.find_first(false);
-      ETL_CONSTEXPR14 size_t bs4fft = bs4.find_first(true);
-      CHECK_EQUAL(0U, bs4fff);
-      CHECK_EQUAL(5U, bs4fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs4(ull(0x20));
+      ETL_CONSTEXPR14 size_t bs4find_first_false = bs4.find_first(false);
+      ETL_CONSTEXPR14 size_t bs4find_first_true  = bs4.find_first(true);
+      CHECK_EQUAL(0U, bs4find_first_false);
+      CHECK_EQUAL(5U, bs4find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs5(ull(0x21));
-      ETL_CONSTEXPR14 size_t bs5fff = bs5.find_first(false);
-      ETL_CONSTEXPR14 size_t bs5fft = bs5.find_first(true);
-      CHECK_EQUAL(1U, bs5fff);
-      CHECK_EQUAL(0U, bs5fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs5(ull(0x21));
+      ETL_CONSTEXPR14 size_t bs5find_first_false = bs5.find_first(false);
+      ETL_CONSTEXPR14 size_t bs5find_first_true  = bs5.find_first(true);
+      CHECK_EQUAL(1U, bs5find_first_false);
+      CHECK_EQUAL(0U, bs5find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs6(ull(0x0E));
-      ETL_CONSTEXPR14 size_t bs6fff = bs6.find_first(false);
-      ETL_CONSTEXPR14 size_t bs6fft = bs6.find_first(true);
-      CHECK_EQUAL(0U, bs6fff);
-      CHECK_EQUAL(1U, bs6fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs6(ull(0x0E));
+      ETL_CONSTEXPR14 size_t bs6find_first_false = bs6.find_first(false);
+      ETL_CONSTEXPR14 size_t bs6find_first_true  = bs6.find_first(true);
+      CHECK_EQUAL(0U, bs6find_first_false);
+      CHECK_EQUAL(1U, bs6find_first_true);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs7(ull(0x31));
-      ETL_CONSTEXPR14 size_t bs7fff = bs7.find_first(false);
-      ETL_CONSTEXPR14 size_t bs7fft = bs7.find_first(true);
-      CHECK_EQUAL(1U, bs7fff);
-      CHECK_EQUAL(0U, bs7fft);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs7(ull(0x31));
+      ETL_CONSTEXPR14 size_t bs7find_first_false = bs7.find_first(false);
+      ETL_CONSTEXPR14 size_t bs7find_first_true  = bs7.find_first(true);
+      CHECK_EQUAL(1U, bs7find_first_false);
+      CHECK_EQUAL(0U, bs7find_first_true);
     }
 
     //*************************************************************************
     TEST(test_find_next)
     {
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00));
-      ETL_CONSTEXPR14 size_t bs1fnf0 = bs1.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs1fnf1 = bs1.find_next(false, 1);
-      ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 2);
-      CHECK_EQUAL(0U, bs1fnf0);
-      CHECK_EQUAL(1U, bs1fnf1);
-      CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs1(ull(0x00));
+      ETL_CONSTEXPR14 size_t bs1find_next_false0 = bs1.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs1find_next_false1 = bs1.find_next(false, 1);
+      ETL_CONSTEXPR14 size_t bs1find_next_true2 = bs1.find_next(true, 2);
+      CHECK_EQUAL(0U, bs1find_next_false0);
+      CHECK_EQUAL(1U, bs1find_next_false1);
+      CHECK_EQUAL(etl::bitset<>::npos, bs1find_next_true2);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF));
-      ETL_CONSTEXPR14 size_t bs2fnt0 = bs2.find_next(true, 0);
-      ETL_CONSTEXPR14 size_t bs2fnt1 = bs2.find_next(true, 1);
-      ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 2);
-      CHECK_EQUAL(0U, bs2fnt0);
-      CHECK_EQUAL(1U, bs2fnt1);
-      CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs2(ull(0xFF));
+      ETL_CONSTEXPR14 size_t bs2find_next_true0 = bs2.find_next(true, 0);
+      ETL_CONSTEXPR14 size_t bs2find_next_true1 = bs2.find_next(true, 1);
+      ETL_CONSTEXPR14 size_t bs2find_next_false2 = bs2.find_next(false, 2);
+      CHECK_EQUAL(0U, bs2find_next_true0);
+      CHECK_EQUAL(1U, bs2find_next_true1);
+      CHECK_EQUAL(etl::bitset<>::npos, bs2find_next_false2);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x0E));
-      ETL_CONSTEXPR14 size_t bs3fnf0 = bs3.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs3fnt1 = bs3.find_next(true, 1);
-      ETL_CONSTEXPR14 size_t bs3fnf2 = bs3.find_next(false, 2);
-      CHECK_EQUAL(0U, bs3fnf0);
-      CHECK_EQUAL(1U, bs3fnt1);
-      CHECK_EQUAL(4U, bs3fnf2);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs3(ull(0x0E));
+      ETL_CONSTEXPR14 size_t bs3find_next_false0 = bs3.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs3find_next_true1 = bs3.find_next(true, 1);
+      ETL_CONSTEXPR14 size_t bs3find_next_false2 = bs3.find_next(false, 2);
+      CHECK_EQUAL(0U, bs3find_next_false0);
+      CHECK_EQUAL(1U, bs3find_next_true1);
+      CHECK_EQUAL(4U, bs3find_next_false2);
 
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x31));
-      ETL_CONSTEXPR14 size_t bs4fnt0 = bs4.find_next(true, 0);
-      ETL_CONSTEXPR14 size_t bs4fnf0 = bs4.find_next(false, 0);
-      ETL_CONSTEXPR14 size_t bs4fnt1 = bs4.find_next(true, 1);
-      CHECK_EQUAL(0U, bs4fnt0);
-      CHECK_EQUAL(1U, bs4fnf0);
-      CHECK_EQUAL(4U, bs4fnt1);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs4(ull(0x31));
+      ETL_CONSTEXPR14 size_t bs4find_next_true0 = bs4.find_next(true, 0);
+      ETL_CONSTEXPR14 size_t bs4find_next_false0 = bs4.find_next(false, 0);
+      ETL_CONSTEXPR14 size_t bs4find_next_true1 = bs4.find_next(true, 1);
+      CHECK_EQUAL(0U, bs4find_next_true0);
+      CHECK_EQUAL(1U, bs4find_next_false0);
+      CHECK_EQUAL(4U, bs4find_next_true1);
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 std::pair<etl::bitset<8, int8_t>, etl::bitset<8, int8_t>> test_swap_helper()
+    ETL_CONSTEXPR14 std::pair<etl::bitset<8, uint8_t>, etl::bitset<8, uint8_t>> test_swap_helper()
     {
-      etl::bitset<8, int8_t> data1(ull(0x2A));
-      etl::bitset<8, int8_t> data2(ull(0x15));
+      etl::bitset<8, uint8_t> data1(ull(0x2A));
+      etl::bitset<8, uint8_t> data2(ull(0x15));
 
       swap(data1, data2);
 
-      return std::pair<etl::bitset<8, int8_t>, etl::bitset<8, int8_t>>(data1, data2);
+      return std::pair<etl::bitset<8, uint8_t>, etl::bitset<8, uint8_t>>(data1, data2);
     }
 
     TEST(test_swap)
     {
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare1(0x2A);
-      ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare2(0x15);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> compare1(0x2A);
+      ETL_CONSTEXPR14 etl::bitset<8, uint8_t> compare2(0x15);
 
-      ETL_CONSTEXPR14 std::pair<etl::bitset<8, int8_t>, etl::bitset<8, int8_t>> swapped = test_swap_helper();
+      ETL_CONSTEXPR14 std::pair<etl::bitset<8, uint8_t>, etl::bitset<8, uint8_t>> swapped = test_swap_helper();
 
       CHECK(swapped.first == compare2);
       CHECK(swapped.second == compare1);
@@ -1516,14 +2209,17 @@ namespace
 
       span_t s = b.span();
       CHECK_EQUAL(0x12345678UL, s[0]);
+
+      s[0] = 0x87654321UL;
+      CHECK_EQUAL(0x87654321UL, b.value<uint32_t>());
     }
 
     //*************************************************************************
     TEST(test_const_span)
     {
-      using span_t = etl::bitset<32, int32_t>::const_span_type;
+      using span_t = etl::bitset<32, uint32_t>::const_span_type;
 
-      const etl::bitset<32, int32_t> b(0x12345678UL);
+      const etl::bitset<32, uint32_t> b(0x12345678UL);
 
       span_t s = b.span();
       CHECK_EQUAL(0x12345678UL, s[0]);
@@ -1532,7 +2228,7 @@ namespace
     //*************************************************************************
     TEST(test_to_string)
     {
-      using bs32 = etl::bitset<32, int32_t>;
+      using bs32 = etl::bitset<32, uint32_t>;
 
       ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
@@ -1547,7 +2243,7 @@ namespace
     //*************************************************************************
     TEST(test_to_wstring)
     {
-      using bs32 = etl::bitset<32, int32_t>;
+      using bs32 = etl::bitset<32, uint32_t>;
 
       ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
@@ -1561,7 +2257,7 @@ namespace
     //*************************************************************************
     TEST(test_to_u16string)
     {
-      using bs32 = etl::bitset<32, int32_t>;
+      using bs32 = etl::bitset<32, uint32_t>;
 
       ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
@@ -1575,7 +2271,7 @@ namespace
     //*************************************************************************
     TEST(test_to_u32string)
     {
-      using bs32 = etl::bitset<32, int32_t>;
+      using bs32 = etl::bitset<32, uint32_t>;
 
       ETL_CONSTEXPR14 bs32 b(0x12345678UL);
 
@@ -1585,5 +2281,521 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    ////*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<int8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 26, 7>();
+      //int8_t v1 = b.extract<int8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), b.extract<int8_t>( 0, 8));
+      CHECK_EQUAL_HEX(int8_t(0x3C), b.extract<int8_t>( 1, 8));
+      CHECK_EQUAL_HEX(int8_t(0x9E), b.extract<int8_t>( 2, 8));
+      CHECK_EQUAL_HEX(int8_t(0xCF), b.extract<int8_t>( 3, 8));
+      CHECK_EQUAL_HEX(int8_t(0x67), b.extract<int8_t>( 4, 8));
+      CHECK_EQUAL_HEX(int8_t(0xB3), b.extract<int8_t>( 5, 8));
+      CHECK_EQUAL_HEX(int8_t(0x59), b.extract<int8_t>( 6, 8));
+      CHECK_EQUAL_HEX(int8_t(0xAC), b.extract<int8_t>( 7, 8));
+      CHECK_EQUAL_HEX(int8_t(0x56), b.extract<int8_t>( 8, 8));
+      CHECK_EQUAL_HEX(int8_t(0x2B), b.extract<int8_t>( 9, 8));
+      CHECK_EQUAL_HEX(int8_t(0x15), b.extract<int8_t>(10, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8A), b.extract<int8_t>(11, 8));
+      CHECK_EQUAL_HEX(int8_t(0x45), b.extract<int8_t>(12, 8));
+      CHECK_EQUAL_HEX(int8_t(0xA2), b.extract<int8_t>(13, 8));
+      CHECK_EQUAL_HEX(int8_t(0xD1), b.extract<int8_t>(14, 8));
+      CHECK_EQUAL_HEX(int8_t(0x68), b.extract<int8_t>(15, 8));
+      CHECK_EQUAL_HEX(int8_t(0x34), b.extract<int8_t>(16, 8));
+      CHECK_EQUAL_HEX(int8_t(0x1A), b.extract<int8_t>(17, 8));
+      CHECK_EQUAL_HEX(int8_t(0x8D), b.extract<int8_t>(18, 8));
+      CHECK_EQUAL_HEX(int8_t(0x46), b.extract<int8_t>(19, 8));
+      CHECK_EQUAL_HEX(int8_t(0x23), b.extract<int8_t>(20, 8));
+      CHECK_EQUAL_HEX(int8_t(0x91), b.extract<int8_t>(21, 8));
+      CHECK_EQUAL_HEX(int8_t(0x48), b.extract<int8_t>(22, 8));
+      CHECK_EQUAL_HEX(int8_t(0x24), b.extract<int8_t>(23, 8));
+      CHECK_EQUAL_HEX(int8_t(0x12), b.extract<int8_t>(24, 8));
+
+      CHECK_THROW(b.extract<int8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int8_t(0x78), (b.extract<int8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract<int8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract<int8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract<int8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x67), (b.extract<int8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract<int8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x59), (b.extract<int8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract<int8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x56), (b.extract<int8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract<int8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract<int8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x45), (b.extract<int8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract<int8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract<int8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x68), (b.extract<int8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x34), (b.extract<int8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract<int8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x46), (b.extract<int8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x23), (b.extract<int8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x91), (b.extract<int8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x48), (b.extract<int8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x24), (b.extract<int8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //int8_t v1 = b.extract<int8_t, 24, 9>();
+      //int8_t v2 = b.extract<int8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), b.extract<int16_t>( 0, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract<int16_t>( 1, 16));
+      CHECK_EQUAL_HEX(int16_t(0x159E), b.extract<int16_t>( 2, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract<int16_t>( 3, 16));
+      CHECK_EQUAL_HEX(int16_t(0x4567), b.extract<int16_t>( 4, 16));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract<int16_t>( 5, 16));
+      CHECK_EQUAL_HEX(int16_t(0xD159), b.extract<int16_t>( 6, 16));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract<int16_t>( 7, 16));
+      CHECK_EQUAL_HEX(int16_t(0x3456), b.extract<int16_t>( 8, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract<int16_t>( 9, 16));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract<int16_t>(10, 16));
+      CHECK_EQUAL_HEX(int16_t(0x468A), b.extract<int16_t>(11, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2345), b.extract<int16_t>(12, 16));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract<int16_t>(13, 16));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract<int16_t>(14, 16));
+      CHECK_EQUAL_HEX(int16_t(0x2468), b.extract<int16_t>(15, 16));
+      CHECK_EQUAL_HEX(int16_t(0x1234), b.extract<int16_t>(16, 16));
+
+      CHECK_THROW(b.extract<int16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<int16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);
+
+      CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract<int16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract<int16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract<int16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract<int16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract<int16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract<int16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract<int16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract<int16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract<int16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract<int16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract<int16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract<int16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract<int16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract<int16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract<int16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract<int16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract<int16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //int16_t v1 = b.extract<int16_t, 16, 17>());
+      //int16_t v2 = b.extract<int16_t, 17, 16>());
+    }
+
+    //*************************************************************************
+    bool test_bit(int i)
+    {
+      return (0x1234 & (1 << i)) != 0;
+    }
+
+    TEST(test_test_run_time)
+    {
+      ETL_CONSTEXPR14 etl::bitset<16, uint16_t> b(0x1234);
+
+      ETL_CONSTEXPR14 bool t0 = b.test(0);
+      ETL_CONSTEXPR14 bool t1 = b.test(1);
+      ETL_CONSTEXPR14 bool t2 = b.test(2);
+      ETL_CONSTEXPR14 bool t3 = b.test(3);
+      ETL_CONSTEXPR14 bool t4 = b.test(4);
+      ETL_CONSTEXPR14 bool t5 = b.test(5);
+      ETL_CONSTEXPR14 bool t6 = b.test(6);
+      ETL_CONSTEXPR14 bool t7 = b.test(7);
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
+
+    //*************************************************************************
+    TEST(test_test_compile_time)
+    {
+      ETL_CONSTEXPR14 etl::bitset<16, uint16_t> b(0x1234);
+
+      ETL_CONSTEXPR14 bool t0 = b.test<0>();
+      ETL_CONSTEXPR14 bool t1 = b.test<1>();
+      ETL_CONSTEXPR14 bool t2 = b.test<2>();
+      ETL_CONSTEXPR14 bool t3 = b.test<3>();
+      ETL_CONSTEXPR14 bool t4 = b.test<4>();
+      ETL_CONSTEXPR14 bool t5 = b.test<5>();
+      ETL_CONSTEXPR14 bool t6 = b.test<6>();
+      ETL_CONSTEXPR14 bool t7 = b.test<7>();
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
   };
 }
diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp
index aeeea766..161417f5 100644
--- a/test/test_bitset_new_ext_default_element_type.cpp
+++ b/test/test_bitset_new_ext_default_element_type.cpp
@@ -37,6 +37,7 @@ SOFTWARE.
 #include "etl/wstring.h"
 #include "etl/u16string.h"
 #include "etl/u32string.h"
+#include "etl/endianness.h"
 
 namespace
 {
@@ -45,14 +46,101 @@ namespace
   SUITE(test_bitset_new_ext_default_element_type)
   {
     //*************************************************************************
-    TEST(test_default_constructor)
+    TEST(test_constants)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      using bitset_type  = etl::bitset_ext<60>;
+      using element_type = bitset_type::element_type;
 
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      constexpr size_t       Size               = 60;
+      constexpr size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
+      constexpr size_t       Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
+      constexpr element_type All_Set_Element    = etl::integral_limits<element_type>::max;
+      constexpr element_type All_Clear_Element  = etl::integral_limits<element_type>::min;
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      //*******************************
+      constexpr size_t Size1 = bitset_type::Size;
+      constexpr size_t Size2 = bitset_type::size();
+
+      CHECK_EQUAL(Size, Size1);
+      CHECK_EQUAL(Size, Size2);
+
+      //*******************************
+      constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
+      constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
+
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
+
+      //*******************************
+      constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
+      constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
+
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
+
+      //*******************************
+      constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
+      constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
+
+      CHECK_EQUAL(All_Set_Element, All_Set_Element1);
+      CHECK_EQUAL(All_Set_Element, All_Set_Element2);
+
+      //*******************************
+      constexpr element_type All_Clear_Element1 = bitset_type::All_Clear_Element;
+      constexpr element_type All_Clear_Element2 = bitset_type::all_clear_element();
+
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
+
+      //*******************************
+      constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
+
+      CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
+
+      //*******************************
+      constexpr char Storage_Model1 = bitset_type::Storage_Model;
+      constexpr char Storage_Model2 = bitset_type::storage_model();
+
+      CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model1);
+      CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model2);
+
+      etl::bitset_storage_model bsm;
+
+      bsm = etl::bitset_storage_model::Undefined;
+      CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Single;
+      CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Multi;
+      CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_buffer)
+    {
+      using BsExt = etl::bitset_ext<64>;
+
+      BsExt::buffer_type buffer;
+      BsExt bs2a(buffer);
+
+      CHECK_THROW(BsExt bs1(nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs2b(bs2a, nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs3(0ULL, nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs4("0", nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs5(L"0", nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs6(u"0", nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs7(U"0", nullptr), etl::bitset_invalid_buffer);
+    }
+
+    //*************************************************************************
+    TEST(test_default_constructor_from_array)
+    {
+      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
+
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -62,721 +150,31 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_default_constructor_multi_element)
+    TEST(test_default_constructor_from_buffer_type)
     {
-      etl::bitset_ext<14, int8_t>::buffer_type buffer14;
-      etl::bitset_ext<30, int16_t>::buffer_type buffer30;
-      etl::bitset_ext<62, int32_t>::buffer_type buffer62;
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
-      etl::bitset_ext<14, int8_t>  data8(buffer14);
-      etl::bitset_ext<30, int16_t> data16(buffer30);
-      etl::bitset_ext<62, int32_t> data32(buffer62);
+      CHECK_EQUAL(compare.size(), data.size());
+      CHECK_EQUAL(compare.count(), data.count());
 
-      CHECK_EQUAL(2U, data8.Number_Of_Elements);
-      CHECK_EQUAL(2U, data16.Number_Of_Elements);
-      CHECK_EQUAL(2U, data32.Number_Of_Elements);
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_default_element_type_bits)
-    {
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<1>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<2>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<3>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<4>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<5>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<6>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<7>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<8>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<9>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<10>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<11>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<12>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<13>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<14>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<15>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<16>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<17>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<18>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<19>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<20>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<21>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<22>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<23>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<24>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<25>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<26>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<27>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<28>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<29>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<30>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<31>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<32>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<33>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<34>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<35>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<36>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<37>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<38>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<39>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<40>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<41>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<42>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<43>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<44>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<45>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<46>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<47>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<48>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<49>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<50>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<51>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<52>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<53>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<54>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<55>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<56>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<57>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<58>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<59>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<60>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<61>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<62>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<63>::element_type>::bits);
-      CHECK_EQUAL(8U, etl::integral_limits<etl::bitset_ext<64>::element_type>::bits);
-    }
-     
-    //*************************************************************************
-    TEST(test_default_constructor_default_element_type_number_of_elements)
-    {
-      CHECK_EQUAL(1U, etl::bitset_ext<1>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<2>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<3>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<4>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<5>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<6>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<7>::Number_Of_Elements);
-      CHECK_EQUAL(1U, etl::bitset_ext<8>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<9>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<10>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<11>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<12>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<13>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<14>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<15>::Number_Of_Elements);
-      CHECK_EQUAL(2U, etl::bitset_ext<16>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<17>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<18>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<19>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<20>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<21>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<22>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<23>::Number_Of_Elements);
-      CHECK_EQUAL(3U, etl::bitset_ext<24>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<25>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<26>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<27>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<28>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<29>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<30>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<31>::Number_Of_Elements);
-      CHECK_EQUAL(4U, etl::bitset_ext<32>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<33>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<34>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<35>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<36>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<37>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<38>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<39>::Number_Of_Elements);
-      CHECK_EQUAL(5U, etl::bitset_ext<40>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<41>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<42>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<43>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<44>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<45>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<46>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<47>::Number_Of_Elements);
-      CHECK_EQUAL(6U, etl::bitset_ext<48>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<49>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<50>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<51>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<52>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<53>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<54>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<55>::Number_Of_Elements);
-      CHECK_EQUAL(7U, etl::bitset_ext<56>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<57>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<58>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<59>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<60>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<61>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<62>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<63>::Number_Of_Elements);
-      CHECK_EQUAL(8U, etl::bitset_ext<64>::Number_Of_Elements);
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int8_t_element_types_bits)
-    {
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<1, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<2, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<3, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<4, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<5, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<6, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<7, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<8, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<9, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<10, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<11, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<12, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<13, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<14, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<15, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<16, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<17, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<18, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<19, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<20, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<21, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<22, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<23, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<24, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<25, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<26, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<27, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<28, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<29, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<30, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<31, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<32, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<33, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<34, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<35, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<36, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<37, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<38, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<39, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<40, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<41, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<42, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<43, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<44, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<45, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<46, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<47, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<48, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<49, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<50, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<51, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<52, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<53, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<54, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<55, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<56, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<57, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<58, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<59, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<60, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<61, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<62, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<63, int8_t>::element_type>::bits));
-      CHECK_EQUAL(8U, (etl::integral_limits<etl::bitset_ext<64, int8_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int8_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset_ext<1, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<2, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<3, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<4, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<5, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<6, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<7, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<8, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<9, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<10, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<11, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<12, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<13, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<14, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<15, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<16, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<17, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<18, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<19, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<20, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<21, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<22, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<23, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<24, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<25, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<26, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<27, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<28, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<29, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<30, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<31, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<32, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<33, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<34, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<35, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<36, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<37, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<38, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<39, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(5U, (etl::bitset_ext<40, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<41, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<42, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<43, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<44, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<45, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<46, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<47, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(6U, (etl::bitset_ext<48, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<49, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<50, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<51, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<52, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<53, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<54, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<55, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(7U, (etl::bitset_ext<56, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<57, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<58, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<59, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<60, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<61, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<62, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<63, int8_t>::Number_Of_Elements));
-      CHECK_EQUAL(8U, (etl::bitset_ext<64, int8_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int16_t_element_types_bits)
-    {
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<1, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<2, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<3, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<4, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<5, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<6, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<7, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<8, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<9, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<10, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<11, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<12, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<13, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<14, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<15, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<16, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<17, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<18, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<19, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<20, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<21, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<22, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<23, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<24, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<25, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<26, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<27, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<28, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<29, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<30, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<31, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<32, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<33, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<34, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<35, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<36, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<37, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<38, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<39, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<40, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<41, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<42, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<43, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<44, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<45, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<46, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<47, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<48, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<49, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<50, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<51, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<52, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<53, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<54, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<55, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<56, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<57, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<58, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<59, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<60, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<61, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<62, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<63, int16_t>::element_type>::bits));
-      CHECK_EQUAL(16U, (etl::integral_limits<etl::bitset_ext<64, int16_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int16_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset_ext<1, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<2, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<3, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<4, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<5, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<6, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<7, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<8, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<9, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<10, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<11, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<12, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<13, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<14, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<15, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<16, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<17, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<18, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<19, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<20, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<21, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<22, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<23, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<24, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<25, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<26, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<27, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<28, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<29, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<30, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<31, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<32, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<33, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<34, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<35, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<36, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<37, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<38, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<39, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<40, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<41, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<42, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<43, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<44, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<45, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<46, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<47, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(3U, (etl::bitset_ext<48, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<49, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<50, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<51, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<52, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<53, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<54, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<55, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<56, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<57, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<58, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<59, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<60, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<61, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<62, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<63, int16_t>::Number_Of_Elements));
-      CHECK_EQUAL(4U, (etl::bitset_ext<64, int16_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int32_t_element_types_bits)
-    {
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<1, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<2, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<3, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<4, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<5, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<6, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<7, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<8, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<9, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<10, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<11, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<12, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<13, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<14, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<15, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<16, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<17, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<18, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<19, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<20, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<21, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<22, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<23, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<24, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<25, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<26, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<27, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<28, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<29, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<30, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<31, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<32, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<33, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<34, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<35, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<36, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<37, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<38, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<39, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<40, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<41, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<42, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<43, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<44, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<45, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<46, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<47, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<48, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<49, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<50, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<51, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<52, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<53, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<54, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<55, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<56, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<57, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<58, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<59, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<60, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<61, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<62, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<63, int32_t>::element_type>::bits));
-      CHECK_EQUAL(32U, (etl::integral_limits<etl::bitset_ext<64, int32_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int32_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset_ext<1, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<2, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<3, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<4, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<5, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<6, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<7, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<8, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<9, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<10, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<11, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<12, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<13, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<14, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<15, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<16, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<17, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<18, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<19, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<20, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<21, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<22, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<23, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<24, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<25, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<26, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<27, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<28, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<29, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<30, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<31, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<32, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<33, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<34, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<35, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<36, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<37, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<38, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<39, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<40, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<41, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<42, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<43, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<44, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<45, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<46, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<47, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<48, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<49, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<50, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<51, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<52, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<53, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<54, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<55, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<56, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<57, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<58, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<59, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<60, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<61, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<62, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<63, int32_t>::Number_Of_Elements));
-      CHECK_EQUAL(2U, (etl::bitset_ext<64, int32_t>::Number_Of_Elements));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int64_t_element_types_bits)
-    {
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<1, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<2, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<3, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<4, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<5, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<6, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<7, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<8, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<9, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<10, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<11, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<12, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<13, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<14, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<15, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<16, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<17, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<18, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<19, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<20, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<21, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<22, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<23, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<24, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<25, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<26, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<27, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<28, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<29, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<30, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<31, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<32, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<33, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<34, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<35, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<36, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<37, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<38, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<39, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<40, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<41, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<42, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<43, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<44, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<45, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<46, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<47, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<48, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<49, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<50, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<51, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<52, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<53, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<54, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<55, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<56, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<57, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<58, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<59, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<60, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<61, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<62, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<63, int64_t>::element_type>::bits));
-      CHECK_EQUAL(64U, (etl::integral_limits<etl::bitset_ext<64, int64_t>::element_type>::bits));
-    }
-
-    //*************************************************************************
-    TEST(test_default_constructor_explicit_int64_t_element_types_number_of_elements)
-    {
-      CHECK_EQUAL(1U, (etl::bitset_ext<1, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<2, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<3, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<4, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<5, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<6, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<7, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<8, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<9, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<10, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<11, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<12, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<13, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<14, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<15, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<16, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<17, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<18, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<19, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<20, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<21, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<22, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<23, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<24, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<25, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<26, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<27, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<28, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<29, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<30, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<31, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<32, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<33, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<34, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<35, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<36, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<37, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<38, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<39, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<40, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<41, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<42, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<43, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<44, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<45, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<46, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<47, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<48, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<49, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<50, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<51, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<52, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<53, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<54, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<55, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<56, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<57, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<58, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<59, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<60, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<61, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<62, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<63, int64_t>::Number_Of_Elements));
-      CHECK_EQUAL(1U, (etl::bitset_ext<64, int64_t>::Number_Of_Elements));
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
     }
 
     //*************************************************************************
     TEST(test_construct_from_value)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      std::bitset<64> compare(0x123456731234567ULL);
+      etl::bitset_ext<64> data(0x123456731234567ULL, buffer1);
 
-      std::bitset<60> compare(0x123456731234567ULL);
-      etl::bitset_ext<60> data(0x123456731234567ULL, buffer);
-
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
+      CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -787,12 +185,11 @@ namespace
     //*************************************************************************
     TEST(test_copy_construct)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-
-      std::bitset<60> compare(0x123456731234567ULL);
-      etl::bitset_ext<60> data(0x123456731234567ULL, buffer1);
-      etl::bitset_ext<60> data_copy(data, buffer2);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      std::bitset<64> compare(0x123456731234567ULL);
+      etl::bitset_ext<64> data(0x123456731234567ULL, buffer1);
+      etl::bitset_ext<64> data_copy(data, buffer2);
 
       CHECK_EQUAL(compare.size(), data_copy.size());
       CHECK_EQUAL(compare.count(), data_copy.count());
@@ -806,12 +203,11 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_excess_value)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(0x8765432187654321ULL);
+      etl::bitset_ext<64> data(0x8765432187654321ULL, buffer);
 
-      std::bitset<60> compare(0x8765432187654321ULL);
-      etl::bitset_ext<60> data(0x8765432187654321ULL, buffer);
-
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -823,12 +219,11 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data("110001001000110100010101100111001100010010001101000101011001", buffer);
 
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data("110001001000110100010101100111001100010010001101000101011001", buffer);
-
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
 
       for (size_t i = 0UL; i < data.size(); ++i)
@@ -840,10 +235,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_wchar_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(L"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(L"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -857,10 +251,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char16_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(u"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(u"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -874,10 +267,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char32_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(U"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(U"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -888,19 +280,68 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char_string)
+    {
+      const char* s = nullptr;
+
+      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<60> data(s, buffer);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_wchar_t_string)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<60> data(s, buffer);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char16_t_string)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<60> data(s, buffer);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char32_t_string)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<60> data(s, buffer);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
     //*************************************************************************
     TEST(test_construct_from_excess_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001");
+      etl::bitset_ext<64> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer);
 
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001111100001");
-      etl::bitset_ext<60> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer);
-
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      CHECK_EQUAL(compare.none(), data.none());
+      CHECK_EQUAL(compare.any(), data.any());
+      CHECK_EQUAL(compare.all(), data.all());
+
+      CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -908,22 +349,55 @@ namespace
       }
     }
 
-    //*************************************************************************    
+    //*************************************************************************
     TEST(test_set)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
+      compare.set();
+      data.set();
+
+      auto size = data.size();
+      auto count = data.count();
+      auto none = data.none();
+      auto any = data.any();
+      auto all = data.all();
+
+      CHECK_EQUAL(compare.size(), size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(), none);
+      CHECK_EQUAL(compare.any(), any);
+      CHECK_EQUAL(compare.all(), all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_less_than_full_size)
+    {
+      etl::bitset_ext<60>::buffer_type buffer;
       std::bitset<60> compare;
       etl::bitset_ext<60> data(buffer);
 
       compare.set();
       data.set();
 
-      CHECK_EQUAL(compare.size(),  data.size());
-      CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      auto size = data.size();
+      auto count = data.count();
+      auto none = data.none();
+      auto any = data.any();
+      auto all = data.all();
+
+      CHECK_EQUAL(compare.size(), size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(), none);
+      CHECK_EQUAL(compare.any(), any);
+      CHECK_EQUAL(compare.all(), all);
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -932,20 +406,264 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char_string_set)
+    TEST(test_set_run_time_position_default_value)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
 
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set(2);
+      data.set(3);
+      data.set(5);
+      data.set(7);
+      data.set(11);
+      data.set(13);
+      data.set(17);
+      data.set(19);
+      data.set(23);
+      data.set(29);
+      data.set(31);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_run_time_position_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set(2, true);
+      data.set(3, true);
+      data.set(5, true);
+      data.set(7, true);
+      data.set(11, true);
+      data.set(13, true);
+      data.set(17, true);
+      data.set(19, true);
+      data.set(23, true);
+      data.set(29, true);
+      data.set(31, true);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_run_time_default_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2>();
+      data.set<3>();
+      data.set<5>();
+      data.set<7>();
+      data.set<11>();
+      data.set<13>();
+      data.set<17>();
+      data.set<19>();
+      data.set<23>();
+      data.set<29>();
+      data.set<31>();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_run_time_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2>(true);
+      data.set<3>(true);
+      data.set<5>(true);
+      data.set<7>(true);
+      data.set<11>(true);
+      data.set<13>(true);
+      data.set<17>(true);
+      data.set<19>(true);
+      data.set<23>(true);
+      data.set<29>(true);
+      data.set<31>(true);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2, true>();
+      data.set<3, true>();
+      data.set<5, true>();
+      data.set<7, true>();
+      data.set<11, true>();
+      data.set<13, true>();
+      data.set<17, true>();
+      data.set<19, true>();
+      data.set<23, true>();
+      data.set<29, true>();
+      data.set<31, true>();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_with_char_string)
+    {
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.set("110001001000110100010101100111001100010010001101000101011001");
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      CHECK_EQUAL(compare.none(), data.none());
+      CHECK_EQUAL(compare.any(), data.any());
+      CHECK_EQUAL(compare.all(), data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -954,12 +672,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_wchar_t_string_set)
+    TEST(test_set_with_wchar_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.set(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -976,12 +693,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char16_t_string_set)
+    TEST(test_set_with_char16_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.set(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -998,12 +714,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char32_t_string_set)
+    TEST(test_set_with_char32_t_string)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.set(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1020,12 +735,63 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char_string)
+    TEST(test_set_from_char_nullptr)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
+      const char* s = nullptr;
 
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+      data.set(s);
+
+      CHECK_EQUAL(64, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+      data.set(s);
+
+      CHECK_EQUAL(64, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+      data.set(s);
+
+      CHECK_EQUAL(64, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char32_t_nullptr)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
+      data.set(s);
+
+      CHECK_EQUAL(64, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char)
+    {
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.from_string("110001001000110100010101100111001100010010001101000101011001");
 
@@ -1042,12 +808,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_wchar_t_string)
+    TEST(test_from_string_with_wchar_t)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.from_string(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1064,12 +829,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char16_t_6string)
+    TEST(test_from_string_with_char16_t)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.from_string(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1086,12 +850,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char32_t_string)
+    TEST(test_from_string_with_char32_t)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
+      etl::bitset_ext<64> data(buffer);
 
       data.from_string(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -1107,11 +870,102 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_from_string_with_char_nullptr)
+    {
+      const char* s = nullptr;
+
+      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<60> data(buffer);
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<60> data(buffer);
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<60> data(buffer);
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char32_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset_ext<60>::buffer_type buffer;
+      etl::bitset_ext<60> data(buffer);
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_value_u8_min)
+    {
+      etl::bitset_ext<8>::buffer_type buffer;
+      etl::bitset_ext<8> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
+      uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_u8_max)
+    {
+      etl::bitset_ext<8>::buffer_type buffer;
+      etl::bitset_ext<8> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
+      uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_s8_min)
+    {
+      etl::bitset_ext<8>::buffer_type buffer;
+      etl::bitset_ext<8> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
+      uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_value_s8_max)
+    {
+      etl::bitset_ext<8>::buffer_type buffer;
+      etl::bitset_ext<8> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
+      uint8_t value = data.value<uint8_t>();
+
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
+    }
+
     //*************************************************************************
     TEST(test_value_u16_min)
     {
       etl::bitset_ext<16>::buffer_type buffer;
-
       etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
       uint16_t value = data.value<uint16_t>();
 
@@ -1122,7 +976,6 @@ namespace
     TEST(test_value_u16_max)
     {
       etl::bitset_ext<16>::buffer_type buffer;
-
       etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
       uint16_t value = data.value<uint16_t>();
 
@@ -1133,29 +986,26 @@ namespace
     TEST(test_value_s16_min)
     {
       etl::bitset_ext<16>::buffer_type buffer;
+      etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
+      uint16_t value = data.value<uint16_t>();
 
-      etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<int16_t>::min, buffer);
-      int16_t value = data.value<int16_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int16_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint16_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s16_max)
     {
       etl::bitset_ext<16>::buffer_type buffer;
+      etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
+      uint16_t value = data.value<uint16_t>();
 
-      etl::bitset_ext<16> data((unsigned long long)etl::integral_limits<int16_t>::max, buffer);
-      int16_t value = data.value<int16_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int16_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint16_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u32_min)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
-
+      etl::bitset_ext<32>::buffer_type buffer;
       etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<uint32_t>::min, buffer);
       uint32_t value = data.value<uint32_t>();
 
@@ -1165,8 +1015,7 @@ namespace
     //*************************************************************************
     TEST(test_value_u32_max)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
-
+      etl::bitset_ext<32>::buffer_type buffer;
       etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<uint32_t>::max, buffer);
       uint32_t value = data.value<uint32_t>();
 
@@ -1176,30 +1025,27 @@ namespace
     //*************************************************************************
     TEST(test_value_s32_min)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      etl::bitset_ext<32>::buffer_type buffer;
+      etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<uint32_t>::min, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<int32_t>::min, buffer);
-      int32_t value = data.value<int32_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int32_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s32_max)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      etl::bitset_ext<32>::buffer_type buffer;
+      etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<uint32_t>::max, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      etl::bitset_ext<32> data((unsigned long long)etl::integral_limits<int32_t>::max, buffer);
-      int32_t value = data.value<int32_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int32_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u64_min)
     {
-      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
-
+      etl::bitset_ext<64>::buffer_type buffer;
       etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<uint64_t>::min, buffer);
       uint64_t value = data.value<uint64_t>();
 
@@ -1209,8 +1055,7 @@ namespace
     //*************************************************************************
     TEST(test_value_u64_max)
     {
-      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
-
+      etl::bitset_ext<64>::buffer_type buffer;
       etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<uint64_t>::max, buffer);
       uint64_t value = data.value<uint64_t>();
 
@@ -1220,32 +1065,85 @@ namespace
     //*************************************************************************
     TEST(test_value_s64_min)
     {
-      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<uint64_t>::min, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<int64_t>::min, buffer);
-      int64_t value = data.value<int64_t>();
-
-      CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s64_max)
     {
-      etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements];
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<uint64_t>::max, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      etl::bitset_ext<64> data((unsigned long long)etl::integral_limits<int64_t>::max, buffer);
-      int64_t value = data.value<int64_t>();
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::max(), value);
+    }
 
-      CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
+    //*************************************************************************
+    TEST(test_to_ulong_min)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits> data(etl::integral_limits<unsigned long>::min, buffer);
+      unsigned long value = data.to_ulong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ulong_max)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits> data(etl::integral_limits<unsigned long>::max, buffer);
+      unsigned long value = data.to_ulong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ulong_overflow)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits + 1>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits + 1> data(etl::integral_limits<unsigned long>::min, buffer);
+      CHECK_THROW(data.to_ulong(), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_min)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits> data(etl::integral_limits<unsigned long long>::min, buffer);
+      unsigned long long value = data.to_ullong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_max)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits> data(etl::integral_limits<unsigned long long>::max, buffer);
+      unsigned long long value = data.to_ullong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long long>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_overflow)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits + 1>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits + 1> data(etl::integral_limits<unsigned long long>::min, buffer);
+      CHECK_THROW(data.to_ullong(), etl::bitset_overflow);
     }
 
     //*************************************************************************
     TEST(test_position_set)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1277,19 +1175,18 @@ namespace
     //*************************************************************************
     TEST(test_reset)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<60> data(0xFFFFFFFFFFFFFFFULL, buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset_ext<64> data(0xFFFFFFFFFFFFFFFULL, buffer);
 
       compare.reset();
       data.reset();
-      
-      CHECK_EQUAL(compare.size(),  data.size());
+
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      CHECK_EQUAL(compare.none(), data.none());
+      CHECK_EQUAL(compare.any(), data.any());
+      CHECK_EQUAL(compare.all(), data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1300,10 +1197,9 @@ namespace
     //*************************************************************************
     TEST(test_position_reset)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<60> data(0xFFFFFFFFFFFFFFFULL, buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset_ext<64> data(0xFFFFFFFFFFFFFFFULL, buffer);
 
       compare.reset(1);
       compare.reset(3);
@@ -1315,11 +1211,11 @@ namespace
       data.reset(7);
       data.reset(13);
 
-      CHECK_EQUAL(compare.size(),  data.size());
+      CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
-      CHECK_EQUAL(compare.none(),  data.none());
-      CHECK_EQUAL(compare.any(),   data.any());
-      CHECK_EQUAL(compare.all(),   data.all());
+      CHECK_EQUAL(compare.none(), data.none());
+      CHECK_EQUAL(compare.any(), data.any());
+      CHECK_EQUAL(compare.all(), data.all());
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -1357,10 +1253,9 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_read)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare(0x3123456731234567ULL);
-      etl::bitset_ext<60> data(0x3123456731234567ULL, buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare(0x3123456731234567ULL);
+      etl::bitset_ext<64> data(0x3123456731234567ULL, buffer);
 
       bool bc0 = compare[1U];
       bool bd0 = data[1U];
@@ -1382,8 +1277,8 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_write)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      etl::bitset_ext<64> data(buffer);
 
       data[1U] = true;
       data[3U] = true;
@@ -1399,15 +1294,14 @@ namespace
     //*************************************************************************
     TEST(test_any)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
-
-      etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<60> data3(ull(0x0000010001000100), buffer3);
-      etl::bitset_ext<60> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.any();
       bool bd2 = data2.any();
@@ -1423,15 +1317,14 @@ namespace
     //*************************************************************************
     TEST(test_none)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
-
-      etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<60> data3(ull(0x0000010001000100), buffer3);
-      etl::bitset_ext<60> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.none();
       bool bd2 = data2.none();
@@ -1446,16 +1339,84 @@ namespace
 
     //*************************************************************************
     TEST(test_all)
+    {
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
+      etl::bitset_ext<64> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.all();
+      bool bd2 = data2.all();
+      bool bd3 = data3.all();
+      bool bd4 = data4.all();
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_any_with_reduced_active_bits)
     {
       etl::bitset_ext<60>::buffer_type buffer1;
       etl::bitset_ext<60>::buffer_type buffer2;
       etl::bitset_ext<60>::buffer_type buffer3;
       etl::bitset_ext<60>::buffer_type buffer4;
-
       etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
       etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<60> data3(ull(0x0000010001000100), buffer3);
-      etl::bitset_ext<60> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<60> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.any();
+      bool bd2 = data2.any();
+      bool bd3 = data3.any();
+      bool bd4 = data4.any();
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60>::buffer_type buffer1;
+      etl::bitset_ext<60>::buffer_type buffer2;
+      etl::bitset_ext<60>::buffer_type buffer3;
+      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.none();
+      bool bd2 = data2.none();
+      bool bd3 = data3.none();
+      bool bd4 = data4.none();
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60>::buffer_type buffer1;
+      etl::bitset_ext<60>::buffer_type buffer2;
+      etl::bitset_ext<60>::buffer_type buffer3;
+      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.all();
       bool bd2 = data2.all();
@@ -1471,9 +1432,9 @@ namespace
     //*************************************************************************
     TEST(test_flip)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       compare.flip();
       data.flip();
@@ -1484,12 +1445,12 @@ namespace
       }
     }
 
-    //*************************************************************************   
+    //*************************************************************************
     TEST(test_flip_position)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       compare.flip(1);
       compare.flip(3);
@@ -1510,9 +1471,9 @@ namespace
     //*************************************************************************
     TEST(test_flip_reference)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       compare[1].flip();
       compare[3].flip();
@@ -1533,10 +1494,9 @@ namespace
     //*************************************************************************
     TEST(test_invert_reference)
     {
-      etl::bitset_ext<60>::buffer_type buffer;
-
-      std::bitset<60> compare;
-      etl::bitset_ext<60> data(buffer);
+      etl::bitset_ext<64>::buffer_type buffer;
+      std::bitset<64> compare;
+      etl::bitset_ext<64> data(buffer);
 
       bool bc = ~compare[3];
       bool bd = ~data[3];
@@ -1544,19 +1504,18 @@ namespace
     }
 
     //*************************************************************************
-    void test_assignment_operator_helper(etl::bitset_ext<60>& from, etl::bitset_ext<60>& to)
+    void test_assignment_operator_helper(etl::bitset_ext<64>&from, etl::bitset_ext<64>&to)
     {
       to = from;
     }
 
     TEST(test_assignment_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-
-      std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<60> data1(0xFFFFFFFFFFFFFFFULL, buffer1);
-      etl::bitset_ext<60> data2(buffer2);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
+      etl::bitset_ext<64> data1(0xFFFFFFFFFFFFFFFULL, buffer1);
+      etl::bitset_ext<64> data2(buffer2);
 
       test_assignment_operator_helper(data1, data2);
 
@@ -1569,15 +1528,14 @@ namespace
     //*************************************************************************
     TEST(test_equality_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64> data1(0x123456781234567ULL, buffer1);
+      etl::bitset_ext<64> data2(0x123456781234567ULL, buffer2);
+      etl::bitset_ext<64> data3(buffer3);
 
-      etl::bitset_ext<60> data1(0x123456781234567ULL, buffer1);
-      etl::bitset_ext<60> data2(0x123456781234567ULL, buffer2);
-      etl::bitset_ext<60> data3(buffer3);
-
-      bool equal     =  (data1 == data2);
+      bool equal = (data1 == data2);
       bool not_equal = !(data1 == data3);
 
       CHECK(equal);
@@ -1587,13 +1545,12 @@ namespace
     //*************************************************************************
     TEST(test_inequality_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-
-      etl::bitset_ext<60> data1(0x123456781234567ULL, buffer1);
-      etl::bitset_ext<60> data2(0x123456781234567ULL, buffer2);
-      etl::bitset_ext<60> data3(buffer3);
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64> data1(0x123456781234567ULL, buffer1);
+      etl::bitset_ext<64> data2(0x123456781234567ULL, buffer2);
+      etl::bitset_ext<64> data3(buffer3);
 
       bool equal = !(data1 != data2);
       bool not_equal = (data1 != data3);
@@ -1603,9 +1560,9 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_shift_left_operator_all_shifts_full_size)
+    TEST(test_shift_left_operator)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
       uint64_t mask = 0xFFFFFFFFFFFFFFFFULL;
 
       etl::bitset_ext<64>::buffer_type buffer1;
@@ -1613,92 +1570,64 @@ namespace
 
       etl::bitset_ext<64> original(0x0123456789ABCDEFULL, buffer1);
 
-      for (ull shift = 0U; shift < 64U; ++shift)
+      for (size_t shift = 0U; shift < 64U; ++shift)
       {
         etl::bitset_ext<64> data(original, buffer2);
-        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<int64_t>());
+
+        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<uint64_t>());
         mask >>= 1;
       }
 
       etl::bitset_ext<64> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<int64_t>());
+      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<uint64_t>());
     }
 
     //*************************************************************************
-    TEST(test_shift_left_operator_all_shifts_partial_size)
+    TEST(test_shift_left_operator_overflow)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
-      uint64_t mask = 0x0FFFFFFFFFFFFFFFULL;
+      etl::bitset_ext<32>::buffer_type buffer1;
+      etl::bitset_ext<32>::buffer_type buffer2;
 
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
+      etl::bitset_ext<32> data(0xFFFFFFFFULL, buffer1);
+      data <<= 1U;
+      etl::bitset_ext<32> shifted(0xFFFFFFFEUL, buffer2);
 
-      etl::bitset_ext<60> original(0x0123456789ABCDEFULL, buffer1);
-
-      for (ull shift = 0U; shift < 64U; ++shift)
-      {        
-        etl::bitset_ext<60> data(original, buffer2);
-        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<int64_t>());
-        mask >>= 1;
-      }
-
-      etl::bitset_ext<60> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<int64_t>());
+      CHECK_EQUAL_HEX(shifted.value<uint32_t>(), data.value<uint32_t>());
     }
 
     //*************************************************************************
-    TEST(test_shift_right_operator_all_shifts_full_size)
+    TEST(test_shift_right_operator)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
 
       etl::bitset_ext<64>::buffer_type buffer1;
       etl::bitset_ext<64>::buffer_type buffer2;
 
       etl::bitset_ext<64> original(0x0123456789ABCDEFULL, buffer1);
 
-      for (ull shift = 0U; shift < 64U; ++shift)
+      for (size_t shift = 0U; shift < 64U; ++shift)
       {
         etl::bitset_ext<64> data(original, buffer2);
-        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<int64_t>());
+        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<uint64_t>());
       }
 
       etl::bitset_ext<64> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<int64_t>());
-    }
-
-    //*************************************************************************
-    TEST(test_shift_right_operator_all_shifts_partial_size)
-    {
-      int64_t value = 0x0123456789ABCDEFULL;
-
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-
-      etl::bitset_ext<60> original(0x0123456789ABCDEFULL, buffer1);
-
-      for (ull shift = 0U; shift < 64U; ++shift)
-      {
-        etl::bitset_ext<60> data(original, buffer2);
-        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<int64_t>());
-      }
-
-      etl::bitset_ext<60> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<int64_t>());
+      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<uint64_t>());
     }
 
     //*************************************************************************
     TEST(test_and_equals_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
 
-      etl::bitset_ext<60> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<60> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<60> data3(0x12345678UL & 0x23456789UL, buffer3);
-      
-      etl::bitset_ext<60> data4(data1, buffer4);
+      etl::bitset_ext<64> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64> data3(0x12345678UL & 0x23456789UL, buffer3);
+
+      etl::bitset_ext<64> data4(data1, buffer4);
       data4 &= data2;
       CHECK(data3 == data4);
     }
@@ -1706,16 +1635,16 @@ namespace
     //*************************************************************************
     TEST(test_or_equals_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
 
-      etl::bitset_ext<60> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<60> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<60> data3(0x12345678UL | 0x23456789UL, buffer3);
+      etl::bitset_ext<64> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64> data3(0x12345678UL | 0x23456789UL, buffer3);
 
-      etl::bitset_ext<60> data4(data1, buffer4);
+      etl::bitset_ext<64> data4(data1, buffer4);
       data4 |= data2;
       CHECK(data3 == data4);
     }
@@ -1723,16 +1652,16 @@ namespace
     //*************************************************************************
     TEST(test_xor_equals_operator)
     {
-      etl::bitset_ext<60>::buffer_type buffer1;
-      etl::bitset_ext<60>::buffer_type buffer2;
-      etl::bitset_ext<60>::buffer_type buffer3;
-      etl::bitset_ext<60>::buffer_type buffer4;
+      etl::bitset_ext<64>::buffer_type buffer1;
+      etl::bitset_ext<64>::buffer_type buffer2;
+      etl::bitset_ext<64>::buffer_type buffer3;
+      etl::bitset_ext<64>::buffer_type buffer4;
 
-      etl::bitset_ext<60> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<60> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<60> data3(0x12345678UL ^ 0x23456789UL, buffer3);
+      etl::bitset_ext<64> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64> data3(0x12345678UL ^ 0x23456789UL, buffer3);
 
-      etl::bitset_ext<60> data4(data1, buffer4);
+      etl::bitset_ext<64> data4(data1, buffer4);
       data4 ^= data2;
       CHECK(data3 == data4);
     }
@@ -1740,66 +1669,57 @@ namespace
     //*************************************************************************
     TEST(test_find_first)
     {
-      etl::bitset_ext<9>::element_type buffer1[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer2[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer3[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer4[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer5[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer6[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer7[etl::bitset_ext<9>::Number_Of_Elements];
+      etl::bitset_ext<8>::buffer_type buffer;
 
-      etl::bitset_ext<9> bs1(ull(0x0000), buffer1);
+      etl::bitset_ext<8> bs1(ull(0x00), buffer);
       size_t bs1fff = bs1.find_first(false);
       size_t bs1fft = bs1.find_first(true);
       CHECK_EQUAL(0U, bs1fff);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fft);
 
-      etl::bitset_ext<9> bs2(ull(0x01FF), buffer2);
+      etl::bitset_ext<8> bs2(ull(0xFF), buffer);
       size_t bs2fff = bs2.find_first(false);
       size_t bs2fft = bs2.find_first(true);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fff);
       CHECK_EQUAL(0U, bs2fft);
 
-      etl::bitset_ext<9> bs3(ull(0x0001), buffer3);
+      etl::bitset_ext<8> bs3(ull(0x01), buffer);
       size_t bs3fff = bs3.find_first(false);
       size_t bs3fft = bs3.find_first(true);
       CHECK_EQUAL(1U, bs3fff);
       CHECK_EQUAL(0U, bs3fft);
 
-      etl::bitset_ext<9> bs4(ull(0x0020), buffer4);
+      etl::bitset_ext<8> bs4(ull(0x20), buffer);
       size_t bs4fff = bs4.find_first(false);
       size_t bs4fft = bs4.find_first(true);
       CHECK_EQUAL(0U, bs4fff);
       CHECK_EQUAL(5U, bs4fft);
 
-      etl::bitset_ext<9> bs5(ull(0x0021), buffer5);
+      etl::bitset_ext<8> bs5(ull(0x21), buffer);
       size_t bs5fff = bs5.find_first(false);
       size_t bs5fft = bs5.find_first(true);
       CHECK_EQUAL(1U, bs5fff);
       CHECK_EQUAL(0U, bs5fft);
 
-      etl::bitset_ext<9> bs6(ull(0x000E), buffer6);
+      etl::bitset_ext<8> bs6(ull(0x0E), buffer);
       size_t bs6fff = bs6.find_first(false);
       size_t bs6fft = bs6.find_first(true);
       CHECK_EQUAL(0U, bs6fff);
       CHECK_EQUAL(1U, bs6fft);
 
-      etl::bitset_ext<9> bs7(ull(0x31), buffer7);
+      etl::bitset_ext<8> bs7(ull(0x31), buffer);
       size_t bs7fff = bs7.find_first(false);
       size_t bs7fft = bs7.find_first(true);
       CHECK_EQUAL(1U, bs7fff);
       CHECK_EQUAL(0U, bs7fft);
     }
-     
+
     //*************************************************************************
     TEST(test_find_next)
     {
-      etl::bitset_ext<9>::element_type buffer1[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer2[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer3[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer4[etl::bitset_ext<9>::Number_Of_Elements];
+      etl::bitset_ext<8>::buffer_type buffer;
 
-      etl::bitset_ext<9> bs1(ull(0x0000), buffer1);
+      etl::bitset_ext<8> bs1(ull(0x00), buffer);
       size_t bs1fnf0 = bs1.find_next(false, 0);
       size_t bs1fnf1 = bs1.find_next(false, 1);
       size_t bs1fnt2 = bs1.find_next(true, 2);
@@ -1807,7 +1727,7 @@ namespace
       CHECK_EQUAL(1U, bs1fnf1);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fnt2);
 
-      etl::bitset_ext<9> bs2(ull(0x1FF), buffer2);
+      etl::bitset_ext<8> bs2(ull(0xFF), buffer);
       size_t bs2fnt0 = bs2.find_next(true, 0);
       size_t bs2fnt1 = bs2.find_next(true, 1);
       size_t bs2fnf2 = bs2.find_next(false, 2);
@@ -1815,7 +1735,7 @@ namespace
       CHECK_EQUAL(1U, bs2fnt1);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fnf2);
 
-      etl::bitset_ext<9> bs3(ull(0x000E), buffer3);
+      etl::bitset_ext<8> bs3(ull(0x0E), buffer);
       size_t bs3fnf0 = bs3.find_next(false, 0);
       size_t bs3fnt1 = bs3.find_next(true, 1);
       size_t bs3fnf2 = bs3.find_next(false, 2);
@@ -1823,7 +1743,7 @@ namespace
       CHECK_EQUAL(1U, bs3fnt1);
       CHECK_EQUAL(4U, bs3fnf2);
 
-      etl::bitset_ext<9> bs4(ull(0x0031), buffer4);
+      etl::bitset_ext<8> bs4(ull(0x31), buffer);
       size_t bs4fnt0 = bs4.find_next(true, 0);
       size_t bs4fnf0 = bs4.find_next(false, 0);
       size_t bs4fnt1 = bs4.find_next(true, 1);
@@ -1832,37 +1752,18 @@ namespace
       CHECK_EQUAL(4U, bs4fnt1);
     }
 
-    //*************************************************************************
-    TEST(test_find_next_github_issue_617)
-    {
-      etl::bitset_ext<64>::element_type buffer1[etl::bitset_ext<64>::Number_Of_Elements];
-      etl::bitset_ext<64>::element_type buffer2[etl::bitset_ext<64>::Number_Of_Elements];
-
-      etl::bitset_ext<64> bs1(ull(0xC000000000000031), buffer1);
-      size_t bs1fnt1 = bs1.find_next(true, 10);
-      size_t bs1fnt2 = bs1.find_next(true, 59);
-      CHECK_EQUAL(62U, bs1fnt1);
-      CHECK_EQUAL(62U, bs1fnt2);
-
-      etl::bitset_ext<64> bs2(ull(0x3FFFFFFFFFFFFFCE), buffer2);
-      size_t bs2fnf1 = bs2.find_next(false, 10);
-      size_t bs2fnf2 = bs2.find_next(false, 59);
-      CHECK_EQUAL(62U, bs2fnf1);
-      CHECK_EQUAL(62U, bs2fnf2);
-    }
-
     //*************************************************************************
     TEST(test_swap)
     {
-      etl::bitset_ext<9>::element_type buffer1[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer2[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer3[etl::bitset_ext<9>::Number_Of_Elements];
-      etl::bitset_ext<9>::element_type buffer4[etl::bitset_ext<9>::Number_Of_Elements];
+      etl::bitset_ext<16>::buffer_type buffer1;
+      etl::bitset_ext<16>::buffer_type buffer2;
+      etl::bitset_ext<16>::buffer_type buffer3;
+      etl::bitset_ext<16>::buffer_type buffer4;
 
-      etl::bitset_ext<9> compare1(0x2A, buffer1);
-      etl::bitset_ext<9> compare2(0x15, buffer2);
-      etl::bitset_ext<9> compare1a(0x2A, buffer3);
-      etl::bitset_ext<9> compare2a(0x15, buffer4);
+      etl::bitset_ext<16> compare1(0x2A, buffer1);
+      etl::bitset_ext<16> compare2(0x15, buffer2);
+      etl::bitset_ext<16> compare1a(0x2A, buffer3);
+      etl::bitset_ext<16> compare2a(0x15, buffer4);
 
       swap(compare1a, compare2a);
 
@@ -1873,55 +1774,83 @@ namespace
     //*************************************************************************
     TEST(test_span)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32   = etl::bitset_ext<32>;
+      using span_t = bs32::span_type;
 
-      using span_t = etl::bitset_ext<32>::span_type;
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
-      etl::bitset_ext<32> data(0x12345678UL, buffer);
+      span_t s = b.span();
 
-      span_t s = data.span();
-      CHECK_EQUAL(0x78U, s[0]);
-      CHECK_EQUAL(0x56U, s[1]);
-      CHECK_EQUAL(0x34U, s[2]);
-      CHECK_EQUAL(0x12U, s[3]);
+      if (etl::endianness::value() == etl::endian::little)
+      {
+        CHECK_EQUAL(0x78UL, s[0]);
+        CHECK_EQUAL(0x56UL, s[1]);
+        CHECK_EQUAL(0x34UL, s[2]);
+        CHECK_EQUAL(0x12UL, s[3]);
+      }
+      else
+      {
+        CHECK_EQUAL(0x78UL, s[3]);
+        CHECK_EQUAL(0x56UL, s[2]);
+        CHECK_EQUAL(0x34UL, s[1]);
+        CHECK_EQUAL(0x12UL, s[0]);
+      }
+
+      s[2] = 0x9AU;
+      uint32_t value = b.value<uint32_t>();
+      CHECK_EQUAL(0x129A5678UL, value);
     }
 
     //*************************************************************************
     TEST(test_const_span)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32   = etl::bitset_ext<32>;
+      using span_t = etl::bitset<32>::const_span_type;
 
-      using span_t = etl::bitset_ext<32>::const_span_type;
-
-      const etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
       span_t s = b.span();
-      CHECK_EQUAL(0x78U, s[0]);
-      CHECK_EQUAL(0x56U, s[1]);
-      CHECK_EQUAL(0x34U, s[2]);
-      CHECK_EQUAL(0x12U, s[3]);
+      if (etl::endianness::value() == etl::endian::little)
+      {
+        CHECK_EQUAL(0x78UL, s[0]);
+        CHECK_EQUAL(0x56UL, s[1]);
+        CHECK_EQUAL(0x34UL, s[2]);
+        CHECK_EQUAL(0x12UL, s[3]);
+      }
+      else
+      {
+        CHECK_EQUAL(0x78UL, s[3]);
+        CHECK_EQUAL(0x56UL, s[2]);
+        CHECK_EQUAL(0x34UL, s[1]);
+        CHECK_EQUAL(0x12UL, s[0]);
+      }
     }
 
     //*************************************************************************
     TEST(test_to_string)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32 = etl::bitset_ext<32>;
 
-      etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 data(0x12345678UL, buffer);
 
-      etl::string<32> text = b.to_string('.', '*');
-      std::string stdtext  = b.to_string<std::string>('.', '*');
+      etl::string<32> text = data.to_string('.', '*');
+      std::string stdtext = data.to_string<std::string>('.', '*');
 
-      CHECK_EQUAL("...*..*...**.*...*.*.**..****...", text.c_str());
-      CHECK_EQUAL("...*..*...**.*...*.*.**..****...", stdtext.c_str());
+      //CHECK_THROW(b.to_string<etl::string<30>>('.', '*'), etl::bitset_ext_overflow);
+      CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(text.c_str()));
+      CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(stdtext.c_str()));
     }
 
     //*************************************************************************
     TEST(test_to_wstring)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32 = etl::bitset_ext<32>;
 
-      etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
       etl::wstring<32> text = b.to_string<etl::wstring<32>>(L'.', L'*');
       std::wstring stdtext = b.to_string<std::wstring>(L'.', L'*');
@@ -1933,9 +1862,10 @@ namespace
     //*************************************************************************
     TEST(test_to_u16string)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32 = etl::bitset_ext<32>;
 
-      etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
       etl::u16string<32> text = b.to_string<etl::u16string<32>>(u'.', u'*');
       std::u16string stdtext = b.to_string<std::u16string>(u'.', u'*');
@@ -1947,9 +1877,10 @@ namespace
     //*************************************************************************
     TEST(test_to_u32string)
     {
-      etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements];
+      using bs32 = etl::bitset_ext<32>;
 
-      etl::bitset_ext<32> b(0x12345678UL, buffer);
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
 
       etl::u32string<32> text = b.to_string<etl::u32string<32>>(U'.', U'*');
       std::u32string stdtext = b.to_string<std::u32string>(U'.', U'*');
@@ -1957,5 +1888,567 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>(0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>(1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>(2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>(3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>(4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>(5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>(6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>(7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>(8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>(9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>(0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>(1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>(2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>(3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>(4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>(5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>(6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>(7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>(8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>(9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t, 0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t, 2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t, 3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t, 4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t, 5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t, 6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t, 7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t, 8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>(0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>(1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>(2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>(3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>(4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>(5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>(6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>(7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>(8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>(9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t, 0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t, 1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t, 2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t, 3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t, 4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t, 5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t, 6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t, 7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t, 8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t, 9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>(0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>(1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>(3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>(4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>(5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>(6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>(7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>(8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t, 0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t, 1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t, 3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t, 4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t, 5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t, 6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t, 7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t, 8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>(0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>(1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>(3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>(4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>(5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>(6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>(7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>(8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>(0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>(1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>(2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>(3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>(4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>(5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>(6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>(7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>(8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>(9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t, 0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t, 1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t, 2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t, 3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t, 4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t, 5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t, 6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t, 7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t, 8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t, 9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>());
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>());
+    }
+
+    //*************************************************************************
+    bool test_bit(int i)
+    {
+      return (0x1234 & (1 << i)) != 0;
+    }
+
+    TEST(test_test_run_time)
+    {
+      etl::bitset_ext<16>::buffer_type buffer;
+
+      etl::bitset_ext<16> b(0x1234, buffer);
+
+      bool t0 = b.test(0);
+      bool t1 = b.test(1);
+      bool t2 = b.test(2);
+      bool t3 = b.test(3);
+      bool t4 = b.test(4);
+      bool t5 = b.test(5);
+      bool t6 = b.test(6);
+      bool t7 = b.test(7);
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
+
+    //*************************************************************************
+    TEST(test_test_compile_time)
+    {
+      etl::bitset_ext<16>::buffer_type buffer;
+
+      etl::bitset_ext<16> b(0x1234, buffer);
+
+      bool t0 = b.test<0>();
+      bool t1 = b.test<1>();
+      bool t2 = b.test<2>();
+      bool t3 = b.test<3>();
+      bool t4 = b.test<4>();
+      bool t5 = b.test<5>();
+      bool t6 = b.test<6>();
+      bool t7 = b.test<7>();
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
   };
 }
diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp
index b7bc74ef..5f36026d 100644
--- a/test/test_bitset_new_ext_explicit_single_element_type.cpp
+++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp
@@ -44,12 +44,100 @@ namespace
 
   SUITE(test_bitset_new_ext_explicit_element_type)
   {
+    //*************************************************************************
+    TEST(test_constants)
+    {
+      using bitset_type  = etl::bitset_ext<60, uint64_t>;
+      using element_type = bitset_type::element_type;
+
+      constexpr size_t       Size               = 60;
+      constexpr size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
+      constexpr size_t       Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
+      constexpr element_type All_Set_Element    = etl::integral_limits<element_type>::max;
+      constexpr element_type All_Clear_Element  = etl::integral_limits<element_type>::min;
+
+      //*******************************
+      constexpr size_t Size1 = bitset_type::Size;
+      constexpr size_t Size2 = bitset_type::size();
+
+      CHECK_EQUAL(Size, Size1);
+      CHECK_EQUAL(Size, Size2);
+
+      //*******************************
+      constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
+      constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
+
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
+      CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
+
+      //*******************************
+      constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
+      constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
+
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
+      CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
+
+      //*******************************
+      constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
+      constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
+
+      CHECK_EQUAL(All_Set_Element, All_Set_Element1);
+      CHECK_EQUAL(All_Set_Element, All_Set_Element2);
+
+      //*******************************
+      constexpr element_type All_Clear_Element1 = bitset_type::All_Clear_Element;
+      constexpr element_type All_Clear_Element2 = bitset_type::all_clear_element();
+
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
+      CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
+
+      //*******************************
+      constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
+
+      CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
+
+      //*******************************
+      constexpr char Storage_Model1 = bitset_type::Storage_Model;
+      constexpr char Storage_Model2 = bitset_type::storage_model();
+
+      CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model1);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model2);
+
+      etl::bitset_storage_model bsm;
+
+      bsm = etl::bitset_storage_model::Undefined;
+      CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Single;
+      CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
+
+      bsm = etl::bitset_storage_model::Multi;
+      CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_buffer)
+    {
+      using BsExt = etl::bitset_ext<64, uint64_t>;
+
+      BsExt::buffer_type buffer;
+      BsExt bs2a(buffer);
+
+      CHECK_THROW(BsExt bs1(nullptr) , etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs2b(bs2a, nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs3(0ULL,  nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs4("0",   nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs5(L"0",  nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs6(u"0",  nullptr), etl::bitset_invalid_buffer);
+      CHECK_THROW(BsExt bs7(U"0",  nullptr), etl::bitset_invalid_buffer);
+    }
+
     //*************************************************************************
     TEST(test_default_constructor_from_array)
     {
-      etl::bitset_ext<64, int64_t>::element_type buffer[etl::bitset_ext<64, int64_t>::Number_Of_Elements];
+      etl::bitset_ext<64, uint64_t>::element_type buffer[etl::bitset_ext<64, uint64_t>::Number_Of_Elements];
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -63,9 +151,9 @@ namespace
     //*************************************************************************
     TEST(test_default_constructor_from_buffer_type)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -79,28 +167,38 @@ namespace
     //*************************************************************************
     TEST(test_default_constructor_single_element)
     {
-      etl::bitset_ext<8,  int8_t>::buffer_type  buffer8;
-      etl::bitset_ext<16, int16_t>::buffer_type buffer16;
-      etl::bitset_ext<32, int32_t>::buffer_type buffer32;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer64;
+      etl::bitset_ext<8,  uint8_t>::buffer_type  buffer8;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer16;
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer32;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer64;
 
-      etl::bitset_ext<8,  int8_t>  data8(buffer8);
-      etl::bitset_ext<16, int16_t> data16(buffer16);
-      etl::bitset_ext<32, int32_t> data32(buffer32);
-      etl::bitset_ext<64, int64_t> data64(buffer64);
+      etl::bitset_ext<8,  uint8_t>  data8(buffer8);
+      etl::bitset_ext<16, uint16_t> data16(buffer16);
+      etl::bitset_ext<32, uint32_t> data32(buffer32);
+      etl::bitset_ext<64, uint64_t> data64(buffer64);
+
+      CHECK_EQUAL(8,  data8.Size);
+      CHECK_EQUAL(16, data16.Size);
+      CHECK_EQUAL(32, data32.Size);
+      CHECK_EQUAL(64, data64.Size);
 
       CHECK_EQUAL(1U, data8.Number_Of_Elements);
       CHECK_EQUAL(1U, data16.Number_Of_Elements);
       CHECK_EQUAL(1U, data32.Number_Of_Elements);
       CHECK_EQUAL(1U, data64.Number_Of_Elements);
+
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data8.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data16.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data32.Storage_Model);
+      CHECK_EQUAL(etl::bitset_storage_model::Single, data64.Storage_Model);
     }
 
     //*************************************************************************
     TEST(test_construct_from_value)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
       std::bitset<64> compare(0x123456731234567ULL);
-      etl::bitset_ext<64, int64_t> data(0x123456731234567ULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data(0x123456731234567ULL, buffer1);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -115,11 +213,11 @@ namespace
     //*************************************************************************
     TEST(test_copy_construct)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
       std::bitset<64> compare(0x123456731234567ULL);
-      etl::bitset_ext<64, int64_t> data(0x123456731234567ULL, buffer1);
-      etl::bitset_ext<64, int64_t> data_copy(data, buffer2);
+      etl::bitset_ext<64, uint64_t> data(0x123456731234567ULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data_copy(data, buffer2);
 
       CHECK_EQUAL(compare.size(), data_copy.size());
       CHECK_EQUAL(compare.count(), data_copy.count());
@@ -133,9 +231,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_excess_value)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(0x8765432187654321ULL);
-      etl::bitset_ext<64, int64_t> data(0x8765432187654321ULL, buffer);
+      etl::bitset_ext<64, uint64_t> data(0x8765432187654321ULL, buffer);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -149,9 +247,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -165,9 +263,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_wchar_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(L"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64, uint64_t> data(L"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -181,9 +279,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char16_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(u"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64, uint64_t> data(u"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -197,9 +295,9 @@ namespace
     //*************************************************************************
     TEST(test_construct_from_char32_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(U"110001001000110100010101100111001100010010001101000101011001", buffer);
+      etl::bitset_ext<64, uint64_t> data(U"110001001000110100010101100111001100010010001101000101011001", buffer);
 
       CHECK_EQUAL(compare.size(), data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -210,12 +308,60 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char_string)
+    {
+      const char* s = nullptr;
+
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(s, buffer);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_wchar_t_string)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(s, buffer);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char16_t_string)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(s, buffer);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_construct_from_nullptr_char32_t_string)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(s, buffer);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
     //*************************************************************************
     TEST(test_construct_from_excess_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001");
-      etl::bitset_ext<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer);
+      etl::bitset_ext<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer);
 
       CHECK_EQUAL(compare.size(),  data.size());
       CHECK_EQUAL(compare.count(), data.count());
@@ -234,9 +380,9 @@ namespace
     //*************************************************************************
     TEST(test_set)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       compare.set();
       data.set();
@@ -260,11 +406,284 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char_string_set)
+    TEST(test_set_less_than_full_size)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      std::bitset<60> compare;
+      etl::bitset_ext<60, uint64_t> data(buffer);
+
+      compare.set();
+      data.set();
+
+      auto size = data.size();
+      auto count = data.count();
+      auto none = data.none();
+      auto any = data.any();
+      auto all = data.all();
+
+      CHECK_EQUAL(compare.size(), size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(), none);
+      CHECK_EQUAL(compare.any(), any);
+      CHECK_EQUAL(compare.all(), all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_run_time_position_default_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set(2);
+      data.set(3);
+      data.set(5);
+      data.set(7);
+      data.set(11);
+      data.set(13);
+      data.set(17);
+      data.set(19);
+      data.set(23);
+      data.set(29);
+      data.set(31);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_run_time_position_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set(2, true);
+      data.set(3, true);
+      data.set(5, true);
+      data.set(7, true);
+      data.set(11, true);
+      data.set(13, true);
+      data.set(17, true);
+      data.set(19, true);
+      data.set(23, true);
+      data.set(29, true);
+      data.set(31, true);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_run_time_default_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2>();
+      data.set<3>();
+      data.set<5>();
+      data.set<7>();
+      data.set<11>();
+      data.set<13>();
+      data.set<17>();
+      data.set<19>();
+      data.set<23>();
+      data.set<29>();
+      data.set<31>();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_run_time_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2>(true);
+      data.set<3>(true);
+      data.set<5>(true);
+      data.set<7>(true);
+      data.set<11>(true);
+      data.set<13>(true);
+      data.set<17>(true);
+      data.set<19>(true);
+      data.set<23>(true);
+      data.set<29>(true);
+      data.set<31>(true);
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_compile_time_position_value)
+    {
+      std::bitset<64> compare;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+
+      compare.set(2);
+      compare.set(3);
+      compare.set(5);
+      compare.set(7);
+      compare.set(11);
+      compare.set(13);
+      compare.set(17);
+      compare.set(19);
+      compare.set(23);
+      compare.set(29);
+      compare.set(31);
+
+      data.set<2, true>();
+      data.set<3, true>();
+      data.set<5, true>();
+      data.set<7, true>();
+      data.set<11, true>();
+      data.set<13, true>();
+      data.set<17, true>();
+      data.set<19, true>();
+      data.set<23, true>();
+      data.set<29, true>();
+      data.set<31, true>();
+
+      auto size  = data.size();
+      auto count = data.count();
+      auto none  = data.none();
+      auto any   = data.any();
+      auto all   = data.all();
+
+      CHECK_EQUAL(compare.size(),  size);
+      CHECK_EQUAL(compare.count(), count);
+      CHECK_EQUAL(compare.none(),  none);
+      CHECK_EQUAL(compare.any(),   any);
+      CHECK_EQUAL(compare.all(),   all);
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        CHECK_EQUAL(compare.test(i), data.test(i));
+      }
+    }
+
+    //*************************************************************************
+    TEST(test_set_with_char_string)
+    {
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.set("110001001000110100010101100111001100010010001101000101011001");
 
@@ -281,11 +700,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_wchar_t_string_set)
+    TEST(test_set_with_wchar_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.set(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -302,11 +721,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char16_t_string_set)
+    TEST(test_set_with_char16_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.set(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -323,11 +742,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_char32_t_string_set)
+    TEST(test_set_with_char32_t_string)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.set(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -344,11 +763,63 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char_string)
+    TEST(test_set_from_char_nullptr)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      const char* s = nullptr;
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+      data.set(s);
+
+      CHECK_EQUAL(64, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+      data.set(s);
+
+      CHECK_EQUAL(64, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+      data.set(s);
+
+      CHECK_EQUAL(64, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_set_from_char32_t_nullptr)
+    {
+      const char32_t* s = nullptr;
+
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
+      data.set(s);
+
+      CHECK_EQUAL(64, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char)
+    {
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.from_string("110001001000110100010101100111001100010010001101000101011001");
 
@@ -365,11 +836,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_wchar_t_string)
+    TEST(test_from_string_with_wchar_t)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.from_string(L"110001001000110100010101100111001100010010001101000101011001");
 
@@ -386,11 +857,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char16_t_6string)
+    TEST(test_from_string_with_char16_t)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.from_string(u"110001001000110100010101100111001100010010001101000101011001");
 
@@ -407,11 +878,11 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_from_char32_t_string)
+    TEST(test_from_string_with_char32_t)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data.from_string(U"110001001000110100010101100111001100010010001101000101011001");
 
@@ -427,11 +898,63 @@ namespace
       }
     }
 
+    //*************************************************************************
+    TEST(test_from_string_with_char_nullptr)
+    {
+      const char* s = nullptr;
+
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(buffer);
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_wchar_t_nullptr)
+    {
+      const wchar_t* s = nullptr;
+
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(buffer);
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char16_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(buffer);
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
+    //*************************************************************************
+    TEST(test_from_string_with_char32_t_nullptr)
+    {
+      const char16_t* s = nullptr;
+
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<60, uint64_t> data(buffer);
+      data.from_string(s);
+
+      CHECK_EQUAL(60, data.size());
+      CHECK_EQUAL(0, data.count());
+    }
+
     //*************************************************************************
     TEST(test_value_u8_min)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
-      etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
       uint8_t value = data.value<uint8_t>();
 
       CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
@@ -440,8 +963,8 @@ namespace
     //*************************************************************************
     TEST(test_value_u8_max)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
-      etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
       uint8_t value = data.value<uint8_t>();
 
       CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
@@ -450,28 +973,28 @@ namespace
     //*************************************************************************
     TEST(test_value_s8_min)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
-      etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits<int8_t>::min, buffer);
-      int8_t value = data.value<int8_t>();
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits<uint8_t>::min, buffer);
+      uint8_t value = data.value<uint8_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int8_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s8_max)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
-      etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits<int8_t>::max, buffer);
-      int8_t value = data.value<int8_t>();
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits<uint8_t>::max, buffer);
+      uint8_t value = data.value<uint8_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int8_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint8_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u16_min)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer;
-      etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+      etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
       uint16_t value = data.value<uint16_t>();
 
       CHECK_EQUAL(std::numeric_limits<uint16_t>::min(), value);
@@ -480,8 +1003,8 @@ namespace
     //*************************************************************************
     TEST(test_value_u16_max)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer;
-      etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+      etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
       uint16_t value = data.value<uint16_t>();
 
       CHECK_EQUAL(std::numeric_limits<uint16_t>::max(), value);
@@ -490,109 +1013,166 @@ namespace
     //*************************************************************************
     TEST(test_value_s16_min)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer;
-      etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits<int16_t>::min, buffer);
-      int16_t value = data.value<int16_t>();
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+      etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits<uint16_t>::min, buffer);
+      uint16_t value = data.value<uint16_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int16_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint16_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s16_max)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer;
-      etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits<int16_t>::max, buffer);
-      int16_t value = data.value<int16_t>();
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+      etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits<uint16_t>::max, buffer);
+      uint16_t value = data.value<uint16_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int16_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint16_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u32_min)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
-      etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits<int32_t>::min, buffer);
-      int32_t value = data.value<int32_t>();
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits<uint32_t>::min, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int32_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u32_max)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
-      etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits<int32_t>::max, buffer);
-      int32_t value = data.value<int32_t>();
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits<uint32_t>::max, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int32_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s32_min)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
-      etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits<int32_t>::min, buffer);
-      int32_t value = data.value<int32_t>();
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits<uint32_t>::min, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int32_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s32_max)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
-      etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits<int32_t>::max, buffer);
-      int32_t value = data.value<int32_t>();
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits<uint32_t>::max, buffer);
+      uint32_t value = data.value<uint32_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int32_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint32_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u64_min)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits<int64_t>::min, buffer);
-      int64_t value = data.value<int64_t>();
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits<uint64_t>::min, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_u64_max)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits<int64_t>::max, buffer);
-      int64_t value = data.value<int64_t>();
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits<uint64_t>::max, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::max(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s64_min)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits<int64_t>::min, buffer);
-      int64_t value = data.value<int64_t>();
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits<uint64_t>::min, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int64_t>::min(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::min(), value);
     }
 
     //*************************************************************************
     TEST(test_value_s64_max)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits<int64_t>::max, buffer);
-      int64_t value = data.value<int64_t>();
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits<uint64_t>::max, buffer);
+      uint64_t value = data.value<uint64_t>();
 
-      CHECK_EQUAL(std::numeric_limits<int64_t>::max(), value);
+      CHECK_EQUAL(std::numeric_limits<uint64_t>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ulong_min)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits, uint64_t> data(etl::integral_limits<unsigned long>::min, buffer);
+      unsigned long value = data.to_ulong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ulong_max)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits, uint64_t> data(etl::integral_limits<unsigned long>::max, buffer);
+      unsigned long value = data.to_ulong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ulong_overflow)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits + 1, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long>::bits + 1, uint64_t> data(etl::integral_limits<unsigned long>::min, buffer);
+      CHECK_THROW(data.to_ulong(), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_min)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits, uint64_t> data(etl::integral_limits<unsigned long long>::min, buffer);
+      unsigned long long value = data.to_ullong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long>::min(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_max)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits, uint64_t> data(etl::integral_limits<unsigned long long>::max, buffer);
+      unsigned long long value = data.to_ullong();
+
+      CHECK_EQUAL(std::numeric_limits<unsigned long long>::max(), value);
+    }
+
+    //*************************************************************************
+    TEST(test_to_ullong_overflow)
+    {
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits + 1, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<etl::integral_limits<unsigned long long>::bits + 1, uint64_t> data(etl::integral_limits<unsigned long long>::min, buffer);    
+      
+      CHECK_THROW(data.to_ullong(), etl::bitset_overflow);
     }
 
     //*************************************************************************
     TEST(test_position_set)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       for (size_t i = 0UL; i < data.size(); ++i)
       {
@@ -624,9 +1204,9 @@ namespace
     //*************************************************************************
     TEST(test_reset)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<64, int64_t> data(0xFFFFFFFFFFFFFFFULL, buffer);
+      etl::bitset_ext<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL, buffer);
 
       compare.reset();
       data.reset();
@@ -646,9 +1226,9 @@ namespace
     //*************************************************************************
     TEST(test_position_reset)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<64, int64_t> data(0xFFFFFFFFFFFFFFFULL, buffer);
+      etl::bitset_ext<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL, buffer);
 
       compare.reset(1);
       compare.reset(3);
@@ -702,9 +1282,9 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_read)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare(0x3123456731234567ULL);
-      etl::bitset_ext<64, int64_t> data(0x3123456731234567ULL, buffer);
+      etl::bitset_ext<64, uint64_t> data(0x3123456731234567ULL, buffer);
 
       bool bc0 = compare[1U];
       bool bd0 = data[1U];
@@ -726,8 +1306,8 @@ namespace
     //*************************************************************************
     TEST(test_index_operator_write)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       data[1U]  = true;
       data[3U]  = true;
@@ -743,14 +1323,14 @@ namespace
     //*************************************************************************
     TEST(test_any)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.any();
       bool bd2 = data2.any();
@@ -766,14 +1346,14 @@ namespace
     //*************************************************************************
     TEST(test_any_with_mask)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0xF000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0xF000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -791,14 +1371,14 @@ namespace
     //*************************************************************************
     TEST(test_none)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.none();
       bool bd2 = data2.none();
@@ -814,14 +1394,14 @@ namespace
     //*************************************************************************
     TEST(test_none_with_mask)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0xF000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0xF000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -839,14 +1419,14 @@ namespace
     //*************************************************************************
     TEST(test_all)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
 
       bool bd1 = data1.all();
       bool bd2 = data2.all();
@@ -862,14 +1442,14 @@ namespace
     //*************************************************************************
     TEST(test_all_with_mask)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
-      etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1);
-      etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2);
-      etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3);
-      etl::bitset_ext<64, int64_t> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<64, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4);
 
       ull mask = ull(0x0FFFFFFFFFFFFFFF);
 
@@ -884,12 +1464,156 @@ namespace
       CHECK_TRUE(bd4);
     }
 
+    //*************************************************************************
+    TEST(test_any_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.any();
+      bool bd2 = data2.any();
+      bool bd3 = data3.any();
+      bool bd4 = data4.any();
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_any_with_mask_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      ull mask = ull(0x0FFFFFFFFFFFFFFF);
+
+      bool bd1 = data1.any(mask);
+      bool bd2 = data2.any(mask);
+      bool bd3 = data3.any(mask);
+      bool bd4 = data4.any(mask);
+
+      CHECK_FALSE(bd1);
+      CHECK_TRUE(bd2);
+      CHECK_TRUE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.none();
+      bool bd2 = data2.none();
+      bool bd3 = data3.none();
+      bool bd4 = data4.none();
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_none_with_mask_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      ull mask = ull(0x0FFFFFFFFFFFFFFF);
+
+      bool bd1 = data1.none(mask);
+      bool bd2 = data2.none(mask);
+      bool bd3 = data3.none(mask);
+      bool bd4 = data4.none(mask);
+
+      CHECK_TRUE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_FALSE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      bool bd1 = data1.all();
+      bool bd2 = data2.all();
+      bool bd3 = data3.all();
+      bool bd4 = data4.all();
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
+    //*************************************************************************
+    TEST(test_all_with_mask_with_reduced_active_bits)
+    {
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<60, uint64_t>::buffer_type buffer4;
+      etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1);
+      etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2);
+      etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3);
+      etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4);
+
+      ull mask = ull(0x00FFFFFFFFFFFFFF);
+
+      bool bd1 = data1.all(mask);
+      bool bd2 = data2.all(mask);
+      bool bd3 = data3.all(mask);
+      bool bd4 = data4.all(mask);
+
+      CHECK_FALSE(bd1);
+      CHECK_FALSE(bd2);
+      CHECK_FALSE(bd3);
+      CHECK_TRUE(bd4);
+    }
+
     //*************************************************************************
     TEST(test_flip)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       compare.flip();
       data.flip();
@@ -903,9 +1627,9 @@ namespace
     //*************************************************************************
     TEST(test_flip_position)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       compare.flip(1);
       compare.flip(3);
@@ -926,9 +1650,9 @@ namespace
     //*************************************************************************
     TEST(test_flip_reference)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       compare[1].flip();
       compare[3].flip();
@@ -949,9 +1673,9 @@ namespace
     //*************************************************************************
     TEST(test_invert_reference)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer;
       std::bitset<64> compare;
-      etl::bitset_ext<64, int64_t> data(buffer);
+      etl::bitset_ext<64, uint64_t> data(buffer);
 
       bool bc = ~compare[3];
       bool bd = ~data[3];
@@ -959,18 +1683,18 @@ namespace
     }
 
     //*************************************************************************
-    void test_assignment_operator_helper(etl::bitset_ext<64, int64_t>& from, etl::bitset_ext<64, int64_t>& to)
+    void test_assignment_operator_helper(etl::bitset_ext<64, uint64_t>& from, etl::bitset_ext<64, uint64_t>& to)
     {
       to = from;
     }
 
     TEST(test_assignment_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
       std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL);
-      etl::bitset_ext<64, int64_t> data1(0xFFFFFFFFFFFFFFFULL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(buffer2);
+      etl::bitset_ext<64, uint64_t> data1(0xFFFFFFFFFFFFFFFULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(buffer2);
 
       test_assignment_operator_helper(data1, data2);
 
@@ -983,12 +1707,12 @@ namespace
     //*************************************************************************
     TEST(test_equality_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t> data1(0x123456781234567ULL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x123456781234567ULL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(buffer3);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t> data1(0x123456781234567ULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x123456781234567ULL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(buffer3);
 
       bool equal     =  (data1 == data2);
       bool not_equal = !(data1 == data3);
@@ -1000,12 +1724,12 @@ namespace
     //*************************************************************************
     TEST(test_inequality_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t> data1(0x123456781234567ULL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x123456781234567ULL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(buffer3);
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t> data1(0x123456781234567ULL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x123456781234567ULL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(buffer3);
 
       bool equal     = !(data1 != data2);
       bool not_equal = (data1 != data3);
@@ -1017,71 +1741,71 @@ namespace
     //*************************************************************************
     TEST(test_shift_left_operator)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
       uint64_t mask = 0xFFFFFFFFFFFFFFFFULL;
 
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
 
-      etl::bitset_ext<64, int64_t> original(0x0123456789ABCDEFULL, buffer1);
+      etl::bitset_ext<64, uint64_t> original(0x0123456789ABCDEFULL, buffer1);
 
-      for (ull shift = 0U; shift < 64U; ++shift)
+      for (size_t shift = 0U; shift < 64ULL; ++shift)
       {
-        etl::bitset_ext<64, int64_t> data(original, buffer2);
-        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<int64_t>());
+        etl::bitset_ext<64, uint64_t> data(original, buffer2);
+        CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value<uint64_t>());
         mask >>= 1;
       }
 
-      etl::bitset_ext<64, int64_t> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<int64_t>());
+      etl::bitset_ext<64, uint64_t> data(original, buffer2);
+      CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value<uint64_t>());
     }
 
     //*************************************************************************
     TEST(test_shift_left_operator_overflow)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer1;
-      etl::bitset_ext<32, int32_t>::buffer_type buffer2;
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer1;
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer2;
 
-      etl::bitset_ext<32, int32_t> data(0xFFFFFFFFULL, buffer1);
+      etl::bitset_ext<32, uint32_t> data(0xFFFFFFFFULL, buffer1);
       data <<= 1U;
-      etl::bitset_ext<32, int32_t> shifted(0xFFFFFFFEUL, buffer2);
+      etl::bitset_ext<32, uint32_t> shifted(0xFFFFFFFEUL, buffer2);
 
-      CHECK_EQUAL_HEX(shifted.value<int32_t>(), data.value<int32_t>());
+      CHECK_EQUAL_HEX(shifted.value<uint32_t>(), data.value<uint32_t>());
     }
 
     //*************************************************************************
     TEST(test_shift_right_operator)
     {
-      int64_t value = 0x0123456789ABCDEFULL;
+      uint64_t value = 0x0123456789ABCDEFULL;
 
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
 
-      etl::bitset_ext<64, int64_t> original(0x0123456789ABCDEFULL, buffer1);
+      etl::bitset_ext<64, uint64_t> original(0x0123456789ABCDEFULL, buffer1);
       
-      for (ull shift = 0U; shift < 64U; ++shift)
+      for (size_t shift = 0U; shift < 64U; ++shift)
       {
-        etl::bitset_ext<64, int64_t> data(original, buffer2);
-        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<int64_t>());
+        etl::bitset_ext<64, uint64_t> data(original, buffer2);
+        CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value<uint64_t>());
       }
 
-      etl::bitset_ext<64, int64_t> data(original, buffer2);
-      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<int64_t>());
+      etl::bitset_ext<64, uint64_t> data(original, buffer2);
+      CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value<uint64_t>());
     }
 
     //*************************************************************************
     TEST(test_and_equals_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
 
-      etl::bitset_ext<64, int64_t> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(0x12345678UL & 0x23456789UL, buffer3);
+      etl::bitset_ext<64, uint64_t> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(0x12345678UL & 0x23456789UL, buffer3);
 
-      etl::bitset_ext<64, int64_t> data4(data1, buffer4);
+      etl::bitset_ext<64, uint64_t> data4(data1, buffer4);
       data4 &= data2;
       CHECK(data3 == data4);
     }
@@ -1089,16 +1813,16 @@ namespace
     //*************************************************************************
     TEST(test_or_equals_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
 
-      etl::bitset_ext<64, int64_t> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(0x12345678UL | 0x23456789UL, buffer3);
+      etl::bitset_ext<64, uint64_t> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(0x12345678UL | 0x23456789UL, buffer3);
 
-      etl::bitset_ext<64, int64_t> data4(data1, buffer4);
+      etl::bitset_ext<64, uint64_t> data4(data1, buffer4);
       data4 |= data2;
       CHECK(data3 == data4);
     }
@@ -1106,16 +1830,16 @@ namespace
     //*************************************************************************
     TEST(test_xor_equals_operator)
     {
-      etl::bitset_ext<64, int64_t>::buffer_type buffer1;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer2;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer3;
-      etl::bitset_ext<64, int64_t>::buffer_type buffer4;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer1;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer2;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer3;
+      etl::bitset_ext<64, uint64_t>::buffer_type buffer4;
 
-      etl::bitset_ext<64, int64_t> data1(0x12345678UL, buffer1);
-      etl::bitset_ext<64, int64_t> data2(0x23456789UL, buffer2);
-      etl::bitset_ext<64, int64_t> data3(0x12345678UL ^ 0x23456789UL, buffer3);
+      etl::bitset_ext<64, uint64_t> data1(0x12345678UL, buffer1);
+      etl::bitset_ext<64, uint64_t> data2(0x23456789UL, buffer2);
+      etl::bitset_ext<64, uint64_t> data3(0x12345678UL ^ 0x23456789UL, buffer3);
 
-      etl::bitset_ext<64, int64_t> data4(data1, buffer4);
+      etl::bitset_ext<64, uint64_t> data4(data1, buffer4);
       data4 ^= data2;
       CHECK(data3 == data4);
     }
@@ -1123,45 +1847,45 @@ namespace
     //*************************************************************************
     TEST(test_find_first)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
 
-      etl::bitset_ext<8, int8_t> bs1(ull(0x00), buffer);
+      etl::bitset_ext<8, uint8_t> bs1(ull(0x00), buffer);
       size_t bs1fff = bs1.find_first(false);
       size_t bs1fft = bs1.find_first(true);
       CHECK_EQUAL(0U, bs1fff);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fft);
 
-      etl::bitset_ext<8, int8_t> bs2(ull(0xFF), buffer);
+      etl::bitset_ext<8, uint8_t> bs2(ull(0xFF), buffer);
       size_t bs2fff = bs2.find_first(false);
       size_t bs2fft = bs2.find_first(true);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fff);
       CHECK_EQUAL(0U, bs2fft);
 
-      etl::bitset_ext<8, int8_t> bs3(ull(0x01), buffer);
+      etl::bitset_ext<8, uint8_t> bs3(ull(0x01), buffer);
       size_t bs3fff = bs3.find_first(false);
       size_t bs3fft = bs3.find_first(true);
       CHECK_EQUAL(1U, bs3fff);
       CHECK_EQUAL(0U, bs3fft);
 
-      etl::bitset_ext<8, int8_t> bs4(ull(0x20), buffer);
+      etl::bitset_ext<8, uint8_t> bs4(ull(0x20), buffer);
       size_t bs4fff = bs4.find_first(false);
       size_t bs4fft = bs4.find_first(true);
       CHECK_EQUAL(0U, bs4fff);
       CHECK_EQUAL(5U, bs4fft);
 
-      etl::bitset_ext<8, int8_t> bs5(ull(0x21), buffer);
+      etl::bitset_ext<8, uint8_t> bs5(ull(0x21), buffer);
       size_t bs5fff = bs5.find_first(false);
       size_t bs5fft = bs5.find_first(true);
       CHECK_EQUAL(1U, bs5fff);
       CHECK_EQUAL(0U, bs5fft);
 
-      etl::bitset_ext<8, int8_t> bs6(ull(0x0E), buffer);
+      etl::bitset_ext<8, uint8_t> bs6(ull(0x0E), buffer);
       size_t bs6fff = bs6.find_first(false);
       size_t bs6fft = bs6.find_first(true);
       CHECK_EQUAL(0U, bs6fff);
       CHECK_EQUAL(1U, bs6fft);
 
-      etl::bitset_ext<8, int8_t> bs7(ull(0x31), buffer);
+      etl::bitset_ext<8, uint8_t> bs7(ull(0x31), buffer);
       size_t bs7fff = bs7.find_first(false);
       size_t bs7fft = bs7.find_first(true);
       CHECK_EQUAL(1U, bs7fff);
@@ -1171,9 +1895,9 @@ namespace
     //*************************************************************************
     TEST(test_find_next)
     {
-      etl::bitset_ext<8, int8_t>::buffer_type buffer;
+      etl::bitset_ext<8, uint8_t>::buffer_type buffer;
 
-      etl::bitset_ext<8, int8_t> bs1(ull(0x00), buffer);
+      etl::bitset_ext<8, uint8_t> bs1(ull(0x00), buffer);
       size_t bs1fnf0 = bs1.find_next(false, 0);
       size_t bs1fnf1 = bs1.find_next(false, 1);
       size_t bs1fnt2 = bs1.find_next(true, 2);
@@ -1181,7 +1905,7 @@ namespace
       CHECK_EQUAL(1U, bs1fnf1);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fnt2);
 
-      etl::bitset_ext<8, int8_t> bs2(ull(0xFF), buffer);
+      etl::bitset_ext<8, uint8_t> bs2(ull(0xFF), buffer);
       size_t bs2fnt0 = bs2.find_next(true, 0);
       size_t bs2fnt1 = bs2.find_next(true, 1);
       size_t bs2fnf2 = bs2.find_next(false, 2);
@@ -1189,7 +1913,7 @@ namespace
       CHECK_EQUAL(1U, bs2fnt1);
       CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fnf2);
 
-      etl::bitset_ext<8, int8_t> bs3(ull(0x0E), buffer);
+      etl::bitset_ext<8, uint8_t> bs3(ull(0x0E), buffer);
       size_t bs3fnf0 = bs3.find_next(false, 0);
       size_t bs3fnt1 = bs3.find_next(true, 1);
       size_t bs3fnf2 = bs3.find_next(false, 2);
@@ -1197,7 +1921,7 @@ namespace
       CHECK_EQUAL(1U, bs3fnt1);
       CHECK_EQUAL(4U, bs3fnf2);
 
-      etl::bitset_ext<8, int8_t> bs4(ull(0x31), buffer);
+      etl::bitset_ext<8, uint8_t> bs4(ull(0x31), buffer);
       size_t bs4fnt0 = bs4.find_next(true, 0);
       size_t bs4fnf0 = bs4.find_next(false, 0);
       size_t bs4fnt1 = bs4.find_next(true, 1);
@@ -1209,15 +1933,15 @@ namespace
     //*************************************************************************
     TEST(test_swap)
     {
-      etl::bitset_ext<16, int16_t>::buffer_type buffer1;
-      etl::bitset_ext<16, int16_t>::buffer_type buffer2;
-      etl::bitset_ext<16, int16_t>::buffer_type buffer3;
-      etl::bitset_ext<16, int16_t>::buffer_type buffer4;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer1;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer2;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer3;
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer4;
 
-      etl::bitset_ext<16, int16_t> compare1(0x2A, buffer1);
-      etl::bitset_ext<16, int16_t> compare2(0x15, buffer2);
-      etl::bitset_ext<16, int16_t> compare1a(0x2A, buffer3);
-      etl::bitset_ext<16, int16_t> compare2a(0x15, buffer4);
+      etl::bitset_ext<16, uint16_t> compare1(0x2A, buffer1);
+      etl::bitset_ext<16, uint16_t> compare2(0x15, buffer2);
+      etl::bitset_ext<16, uint16_t> compare1a(0x2A, buffer3);
+      etl::bitset_ext<16, uint16_t> compare2a(0x15, buffer4);
 
       swap(compare1a, compare2a);
 
@@ -1228,19 +1952,22 @@ namespace
     //*************************************************************************
     TEST(test_span)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer; 
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer; 
       etl::bitset_ext<32, uint32_t> data(0x12345678UL, buffer);
 
       using span_t = etl::bitset_ext<32, uint32_t>::span_type;
 
       span_t s = data.span();
       CHECK_EQUAL(0x12345678UL, s[0]);
+
+      s[0] = 0x87654321UL;
+      CHECK_EQUAL(0x87654321UL, data.value<uint32_t>());
     }
 
     //*************************************************************************
     TEST(test_const_span)
     {
-      etl::bitset_ext<32, int32_t>::buffer_type buffer;
+      etl::bitset_ext<32, uint32_t>::buffer_type buffer;
       const etl::bitset_ext<32, uint32_t> data(0x12345678UL, buffer);
 
       using span_t = const etl::bitset_ext<32, uint32_t>::const_span_type;
@@ -1252,7 +1979,7 @@ namespace
     //*************************************************************************
     TEST(test_to_string)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 data(0x12345678UL, buffer);
@@ -1268,7 +1995,7 @@ namespace
     //*************************************************************************
     TEST(test_to_wstring)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1283,7 +2010,7 @@ namespace
     //*************************************************************************
     TEST(test_to_u16string)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1298,7 +2025,7 @@ namespace
     //*************************************************************************
     TEST(test_to_u32string)
     {
-      using bs32 = etl::bitset_ext<32, int32_t>;
+      using bs32 = etl::bitset_ext<32, uint32_t>;
 
       bs32::buffer_type buffer;
       bs32 b(0x12345678UL, buffer);
@@ -1309,5 +2036,567 @@ namespace
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str()));
       CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str()));
     }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t>( 0, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t>( 1, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t>( 2, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t>( 3, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t>( 4, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t>( 5, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t>( 6, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t>( 7, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t>( 8, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t>( 9, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t>(10, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t>(11, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t>(12, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t>(13, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(14, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t>(15, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t>(16, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t>(17, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t>(18, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t>(19, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t>(20, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t>(21, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t>(22, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t>(23, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t>(24, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t>(25, 6)));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_uint8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract<uint8_t,  0, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract<uint8_t,  2, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract<uint8_t,  3, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract<uint8_t,  4, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract<uint8_t,  5, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract<uint8_t,  6, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract<uint8_t,  7, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract<uint8_t,  8, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract<uint8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract<uint8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract<uint8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract<uint8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract<uint8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract<uint8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract<uint8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract<uint8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract<uint8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract<uint8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t>(0, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t>(1, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t>(2, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t>(3, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t>(4, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t>(5, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t>(6, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t>(7, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t>(8, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t>(9, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t>(10, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t>(11, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t>(12, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t>(13, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(14, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t>(15, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t>(16, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t>(17, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t>(18, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t>(19, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t>(20, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t>(21, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t>(22, 6)));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t>(23, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t>(24, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t>(25, 6)));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t>(26, 6)));
+
+      CHECK_THROW(b.extract<uint8_t>(26, 7), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(27, 6), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_6_bit_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract<int8_t, 0, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract<int8_t, 1, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract<int8_t, 2, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract<int8_t, 3, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract<int8_t, 4, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract<int8_t, 5, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x19), (b.extract<int8_t, 6, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract<int8_t, 7, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x16), (b.extract<int8_t, 8, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract<int8_t, 9, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x15), (b.extract<int8_t, 10, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract<int8_t, 11, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x05), (b.extract<int8_t, 12, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract<int8_t, 13, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 14, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract<int8_t, 15, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract<int8_t, 16, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract<int8_t, 17, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract<int8_t, 18, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x06), (b.extract<int8_t, 19, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract<int8_t, 20, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x11), (b.extract<int8_t, 21, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x08), (b.extract<int8_t, 22, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract<int8_t, 23, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x12), (b.extract<int8_t, 24, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x09), (b.extract<int8_t, 25, 6>()));
+      CHECK_EQUAL_HEX(int8_t(0x04), (b.extract<int8_t, 26, 6>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 26, 7>();
+      //uint8_t v1 = b.extract<uint8_t, 27, 6>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), b.extract<uint8_t>( 0, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract<uint8_t>( 1, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract<uint8_t>( 2, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract<uint8_t>( 3, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x67), b.extract<uint8_t>( 4, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract<uint8_t>( 5, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x59), b.extract<uint8_t>( 6, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract<uint8_t>( 7, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x56), b.extract<uint8_t>( 8, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract<uint8_t>( 9, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x15), b.extract<uint8_t>(10, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract<uint8_t>(11, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x45), b.extract<uint8_t>(12, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract<uint8_t>(13, 8));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract<uint8_t>(14, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x68), b.extract<uint8_t>(15, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x34), b.extract<uint8_t>(16, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract<uint8_t>(17, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract<uint8_t>(18, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x46), b.extract<uint8_t>(19, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x23), b.extract<uint8_t>(20, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x91), b.extract<uint8_t>(21, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x48), b.extract<uint8_t>(22, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x24), b.extract<uint8_t>(23, 8));
+      CHECK_EQUAL_HEX(uint8_t(0x12), b.extract<uint8_t>(24, 8));
+
+      CHECK_THROW(b.extract<uint8_t>(24, 9), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint8_t>(25, 8), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int8_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract<uint8_t,  0, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract<uint8_t,  1, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract<uint8_t,  2, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract<uint8_t,  3, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract<uint8_t,  4, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract<uint8_t,  5, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract<uint8_t,  6, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract<uint8_t,  7, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract<uint8_t,  8, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract<uint8_t,  9, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract<uint8_t, 10, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract<uint8_t, 11, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract<uint8_t, 12, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract<uint8_t, 13, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract<uint8_t, 14, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract<uint8_t, 15, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract<uint8_t, 16, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract<uint8_t, 17, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract<uint8_t, 18, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract<uint8_t, 19, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract<uint8_t, 20, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract<uint8_t, 21, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract<uint8_t, 22, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract<uint8_t, 23, 8>()));
+      CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract<uint8_t, 24, 8>()));
+
+      // The lines below should static assert.
+      //uint8_t v1 = b.extract<uint8_t, 24, 9>();
+      //uint8_t v2 = b.extract<uint8_t, 25, 8>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract<uint16_t>( 0, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract<uint16_t>( 1, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract<uint16_t>( 3, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract<uint16_t>( 4, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract<uint16_t>( 5, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract<uint16_t>( 6, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract<uint16_t>( 7, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract<uint16_t>( 8, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract<uint16_t>(10, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract<uint16_t>(11, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract<uint16_t>(12, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract<uint16_t>(13, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract<uint16_t>(14, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract<uint16_t>(15, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract<uint16_t>(17, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract<uint16_t>(18, 13));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract<uint16_t>(19, 13));
+
+      CHECK_THROW(b.extract<uint16_t>(19, 14), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(20, 13), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_13_bits_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract<uint16_t,  0, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract<uint16_t,  1, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract<uint16_t,  3, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract<uint16_t,  4, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract<uint16_t,  5, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract<uint16_t,  6, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract<uint16_t,  7, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract<uint16_t,  8, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract<uint16_t, 10, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract<uint16_t, 11, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract<uint16_t, 12, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract<uint16_t, 13, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract<uint16_t, 14, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract<uint16_t, 15, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract<uint16_t, 17, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract<uint16_t, 18, 13>()));
+      CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract<uint16_t, 19, 13>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 19, 14);
+      //uint16_t v2 = b.extract<uint16_t, 20, 13);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_uint16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>();
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>();
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_run_time_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract<uint16_t>( 0, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract<uint16_t>( 1, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract<uint16_t>( 2, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract<uint16_t>( 3, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract<uint16_t>( 4, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract<uint16_t>( 5, 16));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract<uint16_t>( 6, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract<uint16_t>( 7, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract<uint16_t>( 8, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract<uint16_t>( 9, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract<uint16_t>(10, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract<uint16_t>(11, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract<uint16_t>(12, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract<uint16_t>(13, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract<uint16_t>(14, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract<uint16_t>(15, 16));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract<uint16_t>(16, 16));
+
+      CHECK_THROW(b.extract<uint16_t>(16, 17), etl::bitset_overflow);
+      CHECK_THROW(b.extract<uint16_t>(17, 16), etl::bitset_overflow);
+    }
+
+    //*************************************************************************
+    TEST(test_extract_int16_t_with_template_parameters)
+    {
+      using bs32 = etl::bitset_ext<32, uint32_t>;
+
+      bs32::buffer_type buffer;
+      bs32 b(0x12345678UL, buffer);
+
+      CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract<uint16_t,  0, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract<uint16_t,  1, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract<uint16_t,  2, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract<uint16_t,  3, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract<uint16_t,  4, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract<uint16_t,  5, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract<uint16_t,  6, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract<uint16_t,  7, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract<uint16_t,  8, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract<uint16_t,  9, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract<uint16_t, 10, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract<uint16_t, 11, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract<uint16_t, 12, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract<uint16_t, 13, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract<uint16_t, 14, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract<uint16_t, 15, 16>()));
+      CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract<uint16_t, 16, 16>()));
+
+      // The lines below should static assert.
+      //uint16_t v1 = b.extract<uint16_t, 16, 17>());
+      //uint16_t v2 = b.extract<uint16_t, 17, 16>());
+    }
+
+    //*************************************************************************
+    bool test_bit(int i)
+    {
+      return (0x1234 & (1 << i)) != 0;
+    }
+
+    TEST(test_test_run_time)
+    {
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+
+      etl::bitset_ext<16, uint16_t> b(0x1234, buffer);
+
+      bool t0 = b.test(0);
+      bool t1 = b.test(1);
+      bool t2 = b.test(2);
+      bool t3 = b.test(3);
+      bool t4 = b.test(4);
+      bool t5 = b.test(5);
+      bool t6 = b.test(6);
+      bool t7 = b.test(7);
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
+
+    //*************************************************************************
+    TEST(test_test_compile_time)
+    {
+      etl::bitset_ext<16, uint16_t>::buffer_type buffer;
+
+      etl::bitset_ext<16, uint16_t> b(0x1234, buffer);
+
+      bool t0 = b.test<0>();
+      bool t1 = b.test<1>();
+      bool t2 = b.test<2>();
+      bool t3 = b.test<3>();
+      bool t4 = b.test<4>();
+      bool t5 = b.test<5>();
+      bool t6 = b.test<6>();
+      bool t7 = b.test<7>();
+
+      CHECK_EQUAL(test_bit(0), t0);
+      CHECK_EQUAL(test_bit(1), t1);
+      CHECK_EQUAL(test_bit(2), t2);
+      CHECK_EQUAL(test_bit(3), t3);
+      CHECK_EQUAL(test_bit(4), t4);
+      CHECK_EQUAL(test_bit(5), t5);
+      CHECK_EQUAL(test_bit(6), t6);
+      CHECK_EQUAL(test_bit(7), t7);
+    }
   };
 }
diff --git a/test/test_callback_service.cpp b/test/test_callback_service.cpp
index 059c617c..c2f89db2 100644
--- a/test/test_callback_service.cpp
+++ b/test/test_callback_service.cpp
@@ -66,11 +66,11 @@ namespace
   //*****************************************************************************
   // The test class with member functions.
   //*****************************************************************************
-  class Test
+  class Object
   {
   public:
 
-    Test()
+    Object()
       : callback(*this)
     {
     }
@@ -88,13 +88,13 @@ namespace
     }
 
     // Callback for 'member1'.
-    etl::function_mp<Test, size_t, &Test::member1> callback;
+    etl::function_mp<Object, size_t, &Object::member1> callback;
   };
 
-  Test test;
+  Object object;
 
   // Callback for 'member2'.
-  etl::function_imp<Test, size_t, test, &Test::member2> member_callback;
+  etl::function_imp<Object, size_t, object, &Object::member2> member_callback;
 
   // Callback for 'global'.
   etl::function_fp<size_t, global> global_callback;
@@ -136,7 +136,7 @@ namespace
       Service service;
 
       service.register_callback<GLOBAL>(global_callback);
-      service.register_callback<MEMBER1>(test.callback);
+      service.register_callback<MEMBER1>(object.callback);
       service.register_callback<MEMBER2>(member_callback);
 
       service.callback<GLOBAL>();
@@ -154,7 +154,7 @@ namespace
       Service service;
 
       service.register_callback(GLOBAL,  global_callback);
-      service.register_callback(MEMBER1, test.callback);
+      service.register_callback(MEMBER1, object.callback);
       service.register_callback(MEMBER2, member_callback);
 
       service.callback(GLOBAL);
@@ -172,7 +172,7 @@ namespace
       Service service;
 
       service.register_callback<GLOBAL>(global_callback);
-      service.register_callback<MEMBER1>(test.callback);
+      service.register_callback<MEMBER1>(object.callback);
       service.register_callback<MEMBER2>(member_callback);
 
       service.callback<MEMBER1>();
@@ -190,7 +190,7 @@ namespace
       Service service;
 
       service.register_callback(GLOBAL,  global_callback);
-      service.register_callback(MEMBER1, test.callback);
+      service.register_callback(MEMBER1, object.callback);
       service.register_callback(MEMBER2, member_callback);
 
       service.callback(MEMBER1);
@@ -208,7 +208,7 @@ namespace
       Service service;
 
       service.register_callback<GLOBAL>(global_callback);
-      service.register_callback<MEMBER1>(test.callback);
+      service.register_callback<MEMBER1>(object.callback);
       service.register_callback<MEMBER2>(member_callback);
 
       service.callback<MEMBER2>();
@@ -226,7 +226,7 @@ namespace
       Service service;
 
       service.register_callback<GLOBAL>(global_callback);
-      service.register_callback<MEMBER1>(test.callback);
+      service.register_callback<MEMBER1>(object.callback);
       service.register_callback<MEMBER2>(member_callback);
 
       service.callback(OUT_OF_RANGE);
@@ -244,7 +244,7 @@ namespace
       Service service;
 
       service.register_callback<GLOBAL>(global_callback);
-      service.register_callback<MEMBER1>(test.callback);
+      service.register_callback<MEMBER1>(object.callback);
       service.register_callback<MEMBER2>(member_callback);
 
       service.register_unhandled_callback(unhandled_callback);
diff --git a/test/test_callback_timer.cpp b/test/test_callback_timer.cpp
index 1057fc08..cdb6bb99 100644
--- a/test/test_callback_timer.cpp
+++ b/test/test_callback_timer.cpp
@@ -49,11 +49,11 @@ namespace
   //***************************************************************************
   // Class callback via etl::function
   //***************************************************************************
-  class Test
+  class Object
   {
   public:
 
-    Test()
+    Object()
       : p_controller(nullptr)
     {
     }
@@ -81,9 +81,9 @@ namespace
     etl::callback_timer<3>* p_controller;
   };
 
-  Test test;
-  etl::function_imv<Test, test, &Test::callback>  member_callback;
-  etl::function_imv<Test, test, &Test::callback2> member_callback2;
+  Object object;
+  etl::function_imv<Object, object, &Object::callback>  member_callback;
+  etl::function_imv<Object, object, &Object::callback2> member_callback2;
 
   //***************************************************************************
   // Free function callback via etl::function
@@ -136,7 +136,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Single_Shot);
       etl::timer::id::type id3 = timer_controller.register_timer(free_callback2,         11, etl::timer::mode::Single_Shot);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -160,11 +160,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -175,7 +175,7 @@ namespace
       etl::callback_timer<1> timer_controller;
 
       etl::timer::id::type id1 = timer_controller.register_timer(member_callback, 37, etl::timer::mode::Single_Shot);
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
       timer_controller.enable(true);
@@ -195,7 +195,7 @@ namespace
       CHECK(timer_controller.set_period(id1, 50));
       timer_controller.start(id1);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       ticks = 0;
 
@@ -207,7 +207,7 @@ namespace
 
       // Timer should have timed out.
 
-      CHECK_EQUAL(50U, *test.tick_list.data());
+      CHECK_EQUAL(50U, *object.tick_list.data());
 
       CHECK(timer_controller.unregister_timer(id1));
       CHECK(!timer_controller.unregister_timer(id1));
@@ -224,7 +224,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_callback2,         11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -248,11 +248,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23, 46, 69, 92 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -266,7 +266,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_callback2,         11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -294,11 +294,11 @@ namespace
       std::vector<uint64_t> compare2 = { 25, 50, 70, 95 };
       std::vector<uint64_t> compare3 = { 15, 25, 35, 45, 55, 70, 80, 90, 100 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -312,7 +312,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_callback2,         11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -347,11 +347,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -368,9 +368,9 @@ namespace
       (void)id2;
       (void)id3;
 
-      test.set_controller(timer_controller);
+      object.set_controller(timer_controller);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
 
@@ -388,9 +388,9 @@ namespace
 
       std::vector<uint64_t> compare1 = { 100, 110, 122 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(), compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(), compare1.size());
     }
 
     //*************************************************************************
@@ -405,9 +405,9 @@ namespace
       (void)id2;
       (void)id3;
 
-      test.set_controller(timer_controller);
+      object.set_controller(timer_controller);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
 
@@ -425,9 +425,9 @@ namespace
 
       std::vector<uint64_t> compare1 = { 102, 111, 123 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
     }
 
     //*************************************************************************
@@ -439,7 +439,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_callback2,         11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -470,11 +470,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -488,7 +488,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_callback2,         11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -518,11 +518,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -536,7 +536,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_callback2,         11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -561,11 +561,11 @@ namespace
       std::vector<uint64_t> compare2 = { 6, 28, 51, 74, 97 };
       std::vector<uint64_t> compare3 = { 16, 27, 38, 49, 60, 71, 82, 93 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -647,7 +647,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(message_timer_time_to_next)
+    TEST(message_timer_time_to_next_repeating)
     {
       etl::callback_timer<3> timer_controller;
 
@@ -694,6 +694,38 @@ namespace
       CHECK_EQUAL(4, timer_controller.time_to_next());
     }
 
+    //*************************************************************************
+    TEST(message_timer_time_to_next_with_has_active_timer)
+    {
+      etl::callback_timer<3> timer_controller;
+
+      etl::timer::id::type id1 = timer_controller.register_timer(member_callback, 37, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id3 = timer_controller.register_timer(free_callback2, 11, etl::timer::mode::Single_Shot);
+
+      timer_controller.start(id1);
+      timer_controller.start(id3);
+      timer_controller.start(id2);
+
+      timer_controller.enable(true);
+
+      timer_controller.tick(11);
+      CHECK_EQUAL(12, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(23);
+      CHECK_EQUAL(3, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(2);
+      CHECK_EQUAL(1, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(1);
+      CHECK_EQUAL(static_cast<etl::timer::interval::type>(etl::timer::interval::No_Active_Interval), timer_controller.time_to_next());
+      CHECK_FALSE(timer_controller.has_active_timer());
+    }
+
     //*************************************************************************
     class test_object
     {
@@ -774,7 +806,7 @@ namespace
       etl::timer::id::type id2 = controller.register_timer(free_function_callback, 100, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = controller.register_timer(free_callback2,          10, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -812,18 +844,18 @@ namespace
       //Join the thread with the main thread
       t1.join();
 
-      CHECK_EQUAL(2U,  test.tick_list.size());
+      CHECK_EQUAL(2U,  object.tick_list.size());
       CHECK_EQUAL(10U, free_tick_list1.size());
       CHECK(free_tick_list2.size() < 65U);
 
       //std::vector<uint64_t> compare1 = { 400, 900 };
       //std::vector<uint64_t> compare2 = { 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 };
 
-      CHECK(test.tick_list.size()  != 0);
+      CHECK(object.tick_list.size()  != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      //CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  min(compare1.size(), test.tick_list.size()));
+      //CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  min(compare1.size(), object.tick_list.size()));
       //CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), min(compare2.size(), free_tick_list1.size()));
     }
 #endif
diff --git a/test/test_callback_timer_atomic.cpp b/test/test_callback_timer_atomic.cpp
index 34980b6b..73047903 100644
--- a/test/test_callback_timer_atomic.cpp
+++ b/test/test_callback_timer_atomic.cpp
@@ -52,11 +52,11 @@ namespace
   //***************************************************************************
   // Class callback via etl::function
   //***************************************************************************
-  class Test
+  class Object
   {
   public:
 
-    Test()
+    Object()
       : p_controller(nullptr)
     {
     }
@@ -86,9 +86,9 @@ namespace
 
   using callback_type = etl::icallback_timer_atomic<std::atomic_uint32_t>::callback_type;
 
-  Test test;
-  callback_type member_callback1 = callback_type::create<Test, test, &Test::callback1>();
-  callback_type member_callback2 = callback_type::create<Test, test, &Test::callback2>();
+  Object object;
+  callback_type member_callback1 = callback_type::create<Object, object, &Object::callback1>();
+  callback_type member_callback2 = callback_type::create<Object, object, &Object::callback2>();
 
   //***************************************************************************
   // Free function callback via etl::function
@@ -143,7 +143,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback1, 23, etl::timer::mode::Single_Shot);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Single_Shot);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -167,11 +167,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -182,7 +182,7 @@ namespace
       etl::callback_timer_atomic<1, std::atomic_uint32_t> timer_controller;
 
       etl::timer::id::type id1 = timer_controller.register_timer(member_callback1, 37, etl::timer::mode::Single_Shot);
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
       timer_controller.enable(true);
@@ -202,7 +202,7 @@ namespace
       CHECK(timer_controller.set_period(id1, 50));
       timer_controller.start(id1);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       ticks = 0;
 
@@ -214,7 +214,7 @@ namespace
 
       // Timer should have timed out.
 
-      CHECK_EQUAL(50U, *test.tick_list.data());
+      CHECK_EQUAL(50U, *object.tick_list.data());
 
       CHECK(timer_controller.unregister_timer(id1));
       CHECK(!timer_controller.unregister_timer(id1));
@@ -231,7 +231,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback1, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -255,11 +255,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23, 46, 69, 92 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -273,7 +273,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback1, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -301,11 +301,11 @@ namespace
       std::vector<uint64_t> compare2 = { 25, 50, 70, 95 };
       std::vector<uint64_t> compare3 = { 15, 25, 35, 45, 55, 70, 80, 90, 100 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -319,7 +319,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback1, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -354,11 +354,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -375,9 +375,9 @@ namespace
       (void)id2;
       (void)id3;
 
-      test.set_controller(timer_controller);
+      object.set_controller(timer_controller);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
 
@@ -395,9 +395,9 @@ namespace
 
       std::vector<uint64_t> compare1 = { 100, 110, 122 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(), compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(), compare1.size());
     }
 
     //*************************************************************************
@@ -412,9 +412,9 @@ namespace
       (void)id2;
       (void)id3;
 
-      test.set_controller(timer_controller);
+      object.set_controller(timer_controller);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
 
@@ -432,9 +432,9 @@ namespace
 
       std::vector<uint64_t> compare1 = { 102, 111, 123 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
     }
 
     //*************************************************************************
@@ -446,7 +446,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback1, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -477,11 +477,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -495,7 +495,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback1, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2,         11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -525,11 +525,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -543,7 +543,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback1, 23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -568,11 +568,11 @@ namespace
       std::vector<uint64_t> compare2 = { 6, 28, 51, 74, 97 };
       std::vector<uint64_t> compare3 = { 16, 27, 38, 49, 60, 71, 82, 93 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
     }
@@ -701,6 +701,38 @@ namespace
       CHECK_EQUAL(4, timer_controller.time_to_next());
     }
 
+    //*************************************************************************
+    TEST(message_timer_time_to_next_with_has_active_timer)
+    {
+      etl::callback_timer_atomic<3, std::atomic_uint32_t> timer_controller;
+
+      etl::timer::id::type id1 = timer_controller.register_timer(member_callback1, 37, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback1, 23, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Single_Shot);
+
+      timer_controller.start(id1);
+      timer_controller.start(id3);
+      timer_controller.start(id2);
+
+      timer_controller.enable(true);
+
+      timer_controller.tick(11);
+      CHECK_EQUAL(12, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(23);
+      CHECK_EQUAL(3, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(2);
+      CHECK_EQUAL(1, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(1);
+      CHECK_EQUAL(static_cast<etl::timer::interval::type>(etl::timer::interval::No_Active_Interval), timer_controller.time_to_next());
+      CHECK_FALSE(timer_controller.has_active_timer());
+    }
+
     //*************************************************************************
     class test_object
     {
@@ -780,7 +812,7 @@ namespace
       etl::timer::id::type id2 = controller.register_timer(free_function_callback1, 100, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = controller.register_timer(free_function_callback2,  10, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -818,18 +850,18 @@ namespace
       //Join the thread with the main thread
       t1.join();
 
-      CHECK_EQUAL(2U,  test.tick_list.size());
+      CHECK_EQUAL(2U,  object.tick_list.size());
       CHECK_EQUAL(10U, free_tick_list1.size());
       CHECK(free_tick_list2.size() < 65U);
 
       //std::vector<uint64_t> compare1 = { 400, 900 };
       //std::vector<uint64_t> compare2 = { 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 };
 
-      CHECK(test.tick_list.size()  != 0);
+      CHECK(object.tick_list.size()  != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      //CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  min(compare1.size(), test.tick_list.size()));
+      //CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  min(compare1.size(), object.tick_list.size()));
       //CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), min(compare2.size(), free_tick_list1.size()));
     }
 #endif
diff --git a/test/test_callback_timer_interrupt.cpp b/test/test_callback_timer_interrupt.cpp
index cbc7d5dd..b0fdba64 100644
--- a/test/test_callback_timer_interrupt.cpp
+++ b/test/test_callback_timer_interrupt.cpp
@@ -65,11 +65,11 @@ namespace
   //***************************************************************************
   // Class callback via etl::delegate
   //***************************************************************************
-  class Test
+  class Object
   {
   public:
 
-    Test()
+    Object()
       : p_controller(nullptr)
     {
     }
@@ -99,9 +99,9 @@ namespace
 
   using callback_type = etl::icallback_timer_interrupt<ScopedGuard>::callback_type;
 
-  Test test;
-  callback_type member_callback  = callback_type::create<Test, test, &Test::callback>();
-  callback_type member_callback2 = callback_type::create<Test, test, &Test::callback2>();
+  Object object;
+  callback_type member_callback  = callback_type::create<Object, object, &Object::callback>();
+  callback_type member_callback2 = callback_type::create<Object, object, &Object::callback2>();
 
   //***************************************************************************
   // Free function callback via etl::function
@@ -158,7 +158,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Single_Shot);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Single_Shot);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -182,11 +182,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -199,7 +199,7 @@ namespace
       etl::callback_timer_interrupt<1, ScopedGuard> timer_controller;
 
       etl::timer::id::type id1 = timer_controller.register_timer(member_callback, 37, etl::timer::mode::Single_Shot);
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
       timer_controller.enable(true);
@@ -219,7 +219,7 @@ namespace
       CHECK(timer_controller.set_period(id1, 50));
       timer_controller.start(id1);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       ticks = 0;
 
@@ -231,7 +231,7 @@ namespace
 
       // Timer should have timed out.
 
-      CHECK_EQUAL(50U, *test.tick_list.data());
+      CHECK_EQUAL(50U, *object.tick_list.data());
 
       CHECK(timer_controller.unregister_timer(id1));
       CHECK(!timer_controller.unregister_timer(id1));
@@ -250,7 +250,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -274,11 +274,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23, 46, 69, 92 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -294,7 +294,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -322,11 +322,11 @@ namespace
       std::vector<uint64_t> compare2 = { 25, 50, 70, 95 };
       std::vector<uint64_t> compare3 = { 15, 25, 35, 45, 55, 70, 80, 90, 100 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -342,7 +342,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -377,11 +377,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -400,9 +400,9 @@ namespace
       (void)id2;
       (void)id3;
 
-      test.set_controller(timer_controller);
+      object.set_controller(timer_controller);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
 
@@ -420,9 +420,9 @@ namespace
 
       std::vector<uint64_t> compare1 = { 100, 110, 122 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(), compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(), compare1.size());
 
       CHECK_EQUAL(0U, ScopedGuard::guard_count);
     }
@@ -439,9 +439,9 @@ namespace
       (void)id2;
       (void)id3;
 
-      test.set_controller(timer_controller);
+      object.set_controller(timer_controller);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
 
@@ -459,9 +459,9 @@ namespace
 
       std::vector<uint64_t> compare1 = { 102, 111, 123 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
 
       CHECK_EQUAL(0U, ScopedGuard::guard_count);
     }
@@ -475,7 +475,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -506,11 +506,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -526,7 +526,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -556,11 +556,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -576,7 +576,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -601,11 +601,11 @@ namespace
       std::vector<uint64_t> compare2 = { 6, 28, 51, 74, 97 };
       std::vector<uint64_t> compare3 = { 16, 27, 38, 49, 60, 71, 82, 93 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -740,6 +740,38 @@ namespace
       CHECK_EQUAL(4, timer_controller.time_to_next());
     }
 
+    //*************************************************************************
+    TEST(message_timer_time_to_next_with_has_active_timer)
+    {
+      etl::callback_timer_interrupt<3, ScopedGuard> timer_controller;
+
+      etl::timer::id::type id1 = timer_controller.register_timer(member_callback, 37, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Single_Shot);
+
+      timer_controller.start(id1);
+      timer_controller.start(id3);
+      timer_controller.start(id2);
+
+      timer_controller.enable(true);
+
+      timer_controller.tick(11);
+      CHECK_EQUAL(12, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(23);
+      CHECK_EQUAL(3, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(2);
+      CHECK_EQUAL(1, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(1);
+      CHECK_EQUAL(static_cast<etl::timer::interval::type>(etl::timer::interval::No_Active_Interval), timer_controller.time_to_next());
+      CHECK_FALSE(timer_controller.has_active_timer());
+    }
+
     //*************************************************************************
     class test_object
     {
diff --git a/test/test_callback_timer_locked.cpp b/test/test_callback_timer_locked.cpp
index 4ca6c3a9..c9f07cd4 100644
--- a/test/test_callback_timer_locked.cpp
+++ b/test/test_callback_timer_locked.cpp
@@ -84,11 +84,11 @@ namespace
   //***************************************************************************
   // Class callback via etl::function
   //***************************************************************************
-  class Test
+  class Object
   {
   public:
 
-    Test()
+    Object()
       : p_controller(nullptr)
     {
     }
@@ -121,9 +121,9 @@ namespace
   using lock_type     = etl::icallback_timer_locked::lock_type;
   using unlock_type   = etl::icallback_timer_locked::unlock_type;
 
-  Test test;
-  callback_type member_callback  = callback_type::create<Test, test, &Test::callback>();
-  callback_type member_callback2 = callback_type::create<Test, test, &Test::callback2>();
+  Object object;
+  callback_type member_callback  = callback_type::create<Object, object, &Object::callback>();
+  callback_type member_callback2 = callback_type::create<Object, object, &Object::callback2>();
 
   //***************************************************************************
   // Free function callback via etl::function
@@ -190,7 +190,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Single_Shot);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Single_Shot);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -214,11 +214,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -236,7 +236,7 @@ namespace
       etl::callback_timer_locked<1> timer_controller(try_lock, lock, unlock);
 
       etl::timer::id::type id1 = timer_controller.register_timer(member_callback, 37, etl::timer::mode::Single_Shot);
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
       timer_controller.enable(true);
@@ -256,7 +256,7 @@ namespace
       CHECK(timer_controller.set_period(id1, 50));
       timer_controller.start(id1);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       ticks = 0;
 
@@ -268,7 +268,7 @@ namespace
 
       // Timer should have timed out.
 
-      CHECK_EQUAL(50U, *test.tick_list.data());
+      CHECK_EQUAL(50U, *object.tick_list.data());
 
       CHECK(timer_controller.unregister_timer(id1));
       CHECK(!timer_controller.unregister_timer(id1));
@@ -292,7 +292,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -316,11 +316,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23, 46, 69, 92 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -341,7 +341,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -369,11 +369,11 @@ namespace
       std::vector<uint64_t> compare2 = { 25, 50, 70, 95 };
       std::vector<uint64_t> compare3 = { 15, 25, 35, 45, 55, 70, 80, 90, 100 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -394,7 +394,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -429,11 +429,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -457,9 +457,9 @@ namespace
       (void)id2;
       (void)id3;
 
-      test.set_controller(timer_controller);
+      object.set_controller(timer_controller);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
 
@@ -477,9 +477,9 @@ namespace
 
       std::vector<uint64_t> compare1 = { 100, 110, 122 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(), compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(), compare1.size());
 
       CHECK_EQUAL(0U, locks.lock_count);
     }
@@ -501,9 +501,9 @@ namespace
       (void)id2;
       (void)id3;
 
-      test.set_controller(timer_controller);
+      object.set_controller(timer_controller);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
 
       timer_controller.start(id1);
 
@@ -521,9 +521,9 @@ namespace
 
       std::vector<uint64_t> compare1 = { 102, 111, 123 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
 
       CHECK_EQUAL(0U, locks.lock_count);
     }
@@ -542,7 +542,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -573,11 +573,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33, 44, 55, 66, 77, 88, 99 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -598,7 +598,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -628,11 +628,11 @@ namespace
       std::vector<uint64_t> compare2 = { 23 };
       std::vector<uint64_t> compare3 = { 11, 22, 33 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -653,7 +653,7 @@ namespace
       etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback,  23, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -678,11 +678,11 @@ namespace
       std::vector<uint64_t> compare2 = { 6, 28, 51, 74, 97 };
       std::vector<uint64_t> compare3 = { 16, 27, 38, 49, 60, 71, 82, 93 };
 
-      CHECK(test.tick_list.size() != 0);
+      CHECK(object.tick_list.size() != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  compare1.size());
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  compare1.size());
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), compare2.size());
       CHECK_ARRAY_EQUAL(compare3.data(), free_tick_list2.data(), compare3.size());
 
@@ -871,6 +871,43 @@ namespace
       CHECK_EQUAL(4, timer_controller.time_to_next());
     }
 
+    //*************************************************************************
+    TEST(message_timer_time_to_next_with_has_active_timer)
+    {
+      locks.clear();
+      try_lock_type try_lock = try_lock_type::create<Locks, locks, &Locks::try_lock>();
+      lock_type     lock     = lock_type::create<Locks, locks, &Locks::lock>();
+      unlock_type   unlock   = unlock_type::create<Locks, locks, &Locks::unlock>();
+
+      etl::callback_timer_locked<3> timer_controller(try_lock, lock, unlock);
+
+      etl::timer::id::type id1 = timer_controller.register_timer(member_callback, 37, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id2 = timer_controller.register_timer(free_function_callback, 23, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id3 = timer_controller.register_timer(free_function_callback2, 11, etl::timer::mode::Single_Shot);
+
+      timer_controller.start(id1);
+      timer_controller.start(id3);
+      timer_controller.start(id2);
+
+      timer_controller.enable(true);
+
+      timer_controller.tick(11);
+      CHECK_EQUAL(12, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(23);
+      CHECK_EQUAL(3, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(2);
+      CHECK_EQUAL(1, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(1);
+      CHECK_EQUAL(static_cast<etl::timer::interval::type>(etl::timer::interval::No_Active_Interval), timer_controller.time_to_next());
+      CHECK_FALSE(timer_controller.has_active_timer());
+    }
+
     //*************************************************************************
 #if REALTIME_TEST
 
@@ -957,7 +994,7 @@ namespace
       etl::timer::id::type id2 = controller.register_timer(free_function_callback,  100, etl::timer::mode::Repeating);
       etl::timer::id::type id3 = controller.register_timer(free_function_callback2,  10, etl::timer::mode::Repeating);
 
-      test.tick_list.clear();
+      object.tick_list.clear();
       free_tick_list1.clear();
       free_tick_list2.clear();
 
@@ -1001,18 +1038,18 @@ namespace
       //Join the thread with the main thread
       t1.join();
 
-      CHECK_EQUAL(2U,  test.tick_list.size());
+      CHECK_EQUAL(2U,  object.tick_list.size());
       CHECK_EQUAL(10U, free_tick_list1.size());
       CHECK(free_tick_list2.size() < 65U);
 
       std::vector<uint64_t> compare1 = { 400, 900 };
       std::vector<uint64_t> compare2 = { 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 };
 
-      CHECK(test.tick_list.size()  != 0);
+      CHECK(object.tick_list.size()  != 0);
       CHECK(free_tick_list1.size() != 0);
       CHECK(free_tick_list2.size() != 0);
 
-      CHECK_ARRAY_EQUAL(compare1.data(), test.tick_list.data(),  min(compare1.size(), test.tick_list.size()));
+      CHECK_ARRAY_EQUAL(compare1.data(), object.tick_list.data(),  min(compare1.size(), object.tick_list.size()));
       CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), min(compare2.size(), free_tick_list1.size()));
 
       CHECK_EQUAL(0U, threadLock.lock_count);
diff --git a/test/test_circular_buffer_external_buffer.cpp b/test/test_circular_buffer_external_buffer.cpp
index 79be1028..271f88d3 100644
--- a/test/test_circular_buffer_external_buffer.cpp
+++ b/test/test_circular_buffer_external_buffer.cpp
@@ -55,15 +55,16 @@ namespace
     using BufferM_t = etl::uninitialized_buffer_of<ItemM, SIZE + 1>;
     using Buffer_t  = etl::uninitialized_buffer_of<Ndc, SIZE + 1>;
 
-    BufferM_t bufferm1;
-    BufferM_t bufferm2;
+    //BufferM_t bufferm1;
+    //BufferM_t bufferm2;
 
-    Buffer_t buffer1;
-    Buffer_t buffer2;
+    //Buffer_t buffer1;
+    //Buffer_t buffer2;
 
     //*************************************************************************
     TEST(test_default_constructor)
     {
+      Buffer_t buffer1;
       Data data(buffer1.raw, SIZE);
 
       CHECK(data.is_valid());
@@ -80,6 +81,8 @@ namespace
     //*************************************************************************
     TEST(test_set_buffer_after_default_constructor)
     {
+      Buffer_t buffer1;
+
       Data data(SIZE);
       CHECK(!data.is_valid());
 
@@ -100,6 +103,7 @@ namespace
     //*************************************************************************
     TEST(test_constructor_from_literal)
     {
+      Buffer_t buffer1;
       Data data({ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") }, buffer1.raw, SIZE);
       Compare compare = { Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
 
@@ -115,6 +119,7 @@ namespace
     //*************************************************************************
     TEST(test_constructor_from_literal_excess)
     {
+      Buffer_t buffer1;
       Data data({ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") }, buffer1.raw, SIZE);
       Compare compare = { Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12")  };
 
@@ -131,6 +136,7 @@ namespace
     //*************************************************************************
     TEST(test_cpp17_deduced_constructor)
     {
+      Buffer_t buffer1;
       Data data({ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") }, buffer1.raw, SIZE);
       Compare compare{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
 
@@ -147,6 +153,7 @@ namespace
 #if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST && !defined(ETL_TEMPLATE_DEDUCTION_GUIDE_TESTS_DISABLED)
     TEST(test_cpp17_deduced_constructor_excess)
     {
+      Buffer_t buffer1;
       Data data({ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") }, buffer1.raw, SIZE);
       Compare compare{ Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12")  };
 
@@ -162,6 +169,7 @@ namespace
     //*************************************************************************
     TEST(test_push)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       for (auto v : test)
@@ -183,6 +191,7 @@ namespace
     //*************************************************************************
     TEST(test_move_push)
     {
+      BufferM_t bufferm1;
       DataM data(bufferm1.raw, SIZE);
       CompareM compare;
 
@@ -203,6 +212,7 @@ namespace
     //*************************************************************************
     TEST(test_push_full_range)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -220,6 +230,7 @@ namespace
     //*************************************************************************
     TEST(test_iterator_to_pointer_operator)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -241,6 +252,7 @@ namespace
     //*************************************************************************
     TEST(test_const_iterator_to_pointer_operator)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -262,6 +274,7 @@ namespace
     //*************************************************************************
     TEST(test_push_full_range_reverse_iterator)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -279,6 +292,7 @@ namespace
     //*************************************************************************
     TEST(test_push_excess_range)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -296,6 +310,7 @@ namespace
     //*************************************************************************
     TEST(test_push_excess_range_reverse_iterator)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -313,6 +328,7 @@ namespace
     //*************************************************************************
     TEST(test_push_short_range_at_start_of_buffer)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -330,6 +346,7 @@ namespace
     //*************************************************************************
     TEST(test_push_short_range_at_start_of_buffer_reverse_iterator)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -347,6 +364,7 @@ namespace
     //*************************************************************************
     TEST(test_push_short_range_at_end_of_buffer)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -365,6 +383,7 @@ namespace
     //*************************************************************************
     TEST(test_push_short_range_at_end_of_buffer_reverse_iterator)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -383,6 +402,7 @@ namespace
     //*************************************************************************
     TEST(test_push_short_range_middle_of_buffer)
     {
+      Buffer_t buffer1;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4") };
       Compare input2{ Ndc("5"), Ndc("6"), Ndc("7") };
       Data data(buffer1.raw, SIZE);
@@ -403,6 +423,7 @@ namespace
     //*************************************************************************
     TEST(test_push_short_range_middle_of_buffer_reverse_iterator)
     {
+      Buffer_t buffer1;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4") };
       Compare input2{ Ndc("5"), Ndc("6"), Ndc("7") };
       Data data(buffer1.raw, SIZE);
@@ -423,6 +444,7 @@ namespace
     //*************************************************************************
     TEST(test_push_short_range_overlap_start_and_end_of_buffer)
     {
+      Buffer_t buffer1;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Compare input2{ Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
@@ -443,6 +465,7 @@ namespace
     //*************************************************************************
     TEST(test_push_short_range_overlap_start_and_end_of_buffer_reverse_iterator)
     {
+      Buffer_t buffer1;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Compare input2{ Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
@@ -463,6 +486,7 @@ namespace
     //*************************************************************************
     TEST(test_available)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       for (auto v : test)
@@ -475,6 +499,7 @@ namespace
     //*************************************************************************
     TEST(test_front)
     {
+      Buffer_t buffer1;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(input1.begin(), input1.end());
@@ -492,6 +517,7 @@ namespace
     //*************************************************************************
     TEST(test_front_const)
     {
+      Buffer_t buffer1;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(input1.begin(), input1.end());
@@ -505,6 +531,7 @@ namespace
     //*************************************************************************
     TEST(test_back)
     {
+      Buffer_t buffer1;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(input1.begin(), input1.end());
@@ -522,6 +549,7 @@ namespace
     //*************************************************************************
     TEST(test_back_const)
     {
+      Buffer_t buffer1;
       Compare input{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(input.begin(), input.end());
@@ -535,7 +563,8 @@ namespace
     //*************************************************************************
     TEST(test_index_operator)
     {
-      // Overrun by 3
+      // Overrun by 3 
+      Buffer_t buffer1;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Compare input2{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
@@ -561,6 +590,7 @@ namespace
     TEST(test_index_operator_const)
     {
       // Overrun by 3
+      Buffer_t buffer1;
       Compare input{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(input.begin(), input.end());
@@ -574,6 +604,7 @@ namespace
     //*************************************************************************
     TEST(test_random_iterator_plus)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -597,6 +628,7 @@ namespace
     //*************************************************************************
     TEST(test_random_iterator_plus_rollover)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -620,6 +652,7 @@ namespace
     //*************************************************************************
     TEST(test_random_iterator_plus_equals)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -643,6 +676,7 @@ namespace
     //*************************************************************************
     TEST(test_random_iterator_plus_equals_rollover)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -666,6 +700,7 @@ namespace
     //*************************************************************************
     TEST(test_random_iterator_minus)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -689,6 +724,7 @@ namespace
     //*************************************************************************
     TEST(test_random_iterator_minus_rollover)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -712,6 +748,7 @@ namespace
     //*************************************************************************
     TEST(test_random_iterator_minus_equals)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -735,6 +772,7 @@ namespace
     //*************************************************************************
     TEST(test_random_iterator_minus_equals_rollover)
     {
+      Buffer_t buffer1;
       Compare input{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(input.begin(), input.end());
@@ -758,6 +796,8 @@ namespace
     //*************************************************************************
     TEST(test_copy_constructor)
     {
+      Buffer_t buffer1;
+      Buffer_t buffer2;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9") };
       Compare input2{ Ndc("9"), Ndc("8"), Ndc("7"), Ndc("6"), Ndc("5"), Ndc("4"), Ndc("3"), Ndc("2"), Ndc("1"), Ndc("0") };
       Data data1(buffer1.raw, SIZE);
@@ -781,6 +821,8 @@ namespace
     //*************************************************************************
     TEST(test_move_constructor)
     {
+      BufferM_t bufferm1;
+      BufferM_t bufferm2;
       CompareM input1;
       CompareM input2;
       CompareM compare;
@@ -819,6 +861,8 @@ namespace
     //*************************************************************************
     TEST(test_assignment)
     {
+      Buffer_t buffer1;
+      Buffer_t buffer2;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8") };
       Compare input2{ Ndc("8"), Ndc("7"), Ndc("6"), Ndc("5"), Ndc("4"), Ndc("3"), Ndc("2"), Ndc("1"), Ndc("0") };
       Data data1(buffer1.raw, SIZE);
@@ -845,6 +889,8 @@ namespace
     //*************************************************************************
     TEST(test_move_assignment)
     {
+      Buffer_t buffer1;
+      Buffer_t buffer2;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8") };
       Compare input2{ Ndc("8"), Ndc("7"), Ndc("6"), Ndc("5"), Ndc("4"), Ndc("3"), Ndc("2"), Ndc("1"), Ndc("0") };
       Data data1(buffer1.raw, SIZE);
@@ -871,6 +917,7 @@ namespace
     //*************************************************************************
     TEST(test_swap_iterator)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -893,6 +940,7 @@ namespace
     //*************************************************************************
     TEST(test_swap_const_iterator)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -915,6 +963,7 @@ namespace
     //*************************************************************************
     TEST(test_iterator_difference)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -940,6 +989,7 @@ namespace
     //*************************************************************************
     TEST(test_const_iterator_difference)
     {
+      Buffer_t buffer1;
       Compare test{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data(buffer1.raw, SIZE);
       data.push(test.begin(), test.end());
@@ -987,6 +1037,7 @@ namespace
     TEST(test_equal)
     {
       // Over-write by 3
+      Buffer_t buffer1;
       Compare input{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data1(buffer1.raw, SIZE);
       Data data2(buffer1.raw, SIZE);
@@ -1000,6 +1051,8 @@ namespace
     TEST(test_not_equal)
     {
       // Over-write by 3
+      Buffer_t buffer1;
+      Buffer_t buffer2;
       Compare input1{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("7"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Compare input2{ Ndc("0"), Ndc("1"), Ndc("2"), Ndc("3"), Ndc("4"), Ndc("5"), Ndc("6"), Ndc("6"), Ndc("8"), Ndc("9"), Ndc("10"), Ndc("11"), Ndc("12") };
       Data data1(buffer1.raw, SIZE);
diff --git a/test/test_circular_iterator.cpp b/test/test_circular_iterator.cpp
index 2e5d77a1..191b4ad5 100644
--- a/test/test_circular_iterator.cpp
+++ b/test/test_circular_iterator.cpp
@@ -8,7 +8,7 @@ https://www.etlcpp.com
 Copyright(c) 2022 John Wellbelove
 
 Permission is hereby granted, free of charge, to any person obtaining data copy
-of this software and associated documentation ciles(the "Software"), to deal
+of this software and associated documentation files(the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 copies of the Software, and to permit persons to whom the Software is
@@ -470,46 +470,46 @@ namespace
     //*************************************************************************
     TEST(test_member_dereference_operator_for_random_access_iterator)
     {
-      struct Test
+      struct Object
       {
         int data;
         int b;
       };
 
-      Test test[] = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
+      Object object[] = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
 
-      etl::circular_iterator<Test*> ci(std::begin(test), std::end(test));
+      etl::circular_iterator<Object*> ci(std::begin(object), std::end(object));
 
-      CHECK_EQUAL(test[0].data, ci->data);
-      CHECK_EQUAL(test[0].b, ci->b);
+      CHECK_EQUAL(object[0].data, ci->data);
+      CHECK_EQUAL(object[0].b, ci->b);
 
       *ci = { 7, 8 };
 
-      CHECK_EQUAL(test[0].data, ci->data);
-      CHECK_EQUAL(test[0].b, ci->b);
+      CHECK_EQUAL(object[0].data, ci->data);
+      CHECK_EQUAL(object[0].b, ci->b);
 
       ++ci;
-      CHECK_EQUAL(test[1].data, ci->data);
-      CHECK_EQUAL(test[1].b, ci->b);
+      CHECK_EQUAL(object[1].data, ci->data);
+      CHECK_EQUAL(object[1].b, ci->b);
 
       ++ci;
-      CHECK_EQUAL(test[2].data, ci->data);
-      CHECK_EQUAL(test[2].b, ci->b);
+      CHECK_EQUAL(object[2].data, ci->data);
+      CHECK_EQUAL(object[2].b, ci->b);
     }
 
     //*************************************************************************
     TEST(test_member_dereference_operator_for_bidirectional_iterator)
     {
-      struct Test
+      struct Object
       {
         int data;
         int b;
       };
 
-      std::list<Test> test = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
-      std::list<Test>::iterator itr = test.begin();
+      std::list<Object> object = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
+      std::list<Object>::iterator itr = object.begin();
 
-      etl::circular_iterator<std::list<Test>::iterator> ci(std::begin(test), std::end(test));
+      etl::circular_iterator<std::list<Object>::iterator> ci(std::begin(object), std::end(object));
 
       CHECK_EQUAL(itr->b, ci->b);
 
@@ -528,16 +528,16 @@ namespace
     //*************************************************************************
     TEST(test_member_dereference_operator_for_forward_iterator)
     {
-      struct Test
+      struct Object
       {
         int data;
         int b;
       };
 
-      std::forward_list<Test> test = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
-      std::forward_list<Test>::iterator itr = test.begin();
+      std::forward_list<Object> object = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
+      std::forward_list<Object>::iterator itr = object.begin();
 
-      etl::circular_iterator<std::forward_list<Test>::iterator> ci(std::begin(test), std::end(test));
+      etl::circular_iterator<std::forward_list<Object>::iterator> ci(std::begin(object), std::end(object));
 
       CHECK_EQUAL(itr->b, ci->b);
 
diff --git a/test/test_compare.cpp b/test/test_compare.cpp
index a11d611a..f0de4b26 100644
--- a/test/test_compare.cpp
+++ b/test/test_compare.cpp
@@ -37,58 +37,70 @@ namespace
 
   typedef etl::compare<int> CompareInt;
 
-  struct Test
+  struct Object
   {
     int a;
     int b;
   };
 
-  Test ta = { 1, 2 };
-  Test tb = { 2, 3 };
+  Object ta = { 1, 2 };
+  Object tb = { 2, 3 };
 
   //***********************************
-  bool operator <(const Test& lhs, const Test& rhs)
+  bool constexpr operator <(const Object& lhs, const Object& rhs)
   {
     return (lhs.a + lhs.b) < (rhs.a + rhs.b);
   }
 
   //***********************************
-  bool operator >(const Test& lhs, const Test& rhs)
+  bool constexpr operator >(const Object& lhs, const Object& rhs)
   {
     return (lhs.a + lhs.b) > (rhs.a + rhs.b);
   }
 
   //***********************************
-  bool operator <=(const Test& lhs, const Test& rhs)
+  bool constexpr operator <=(const Object& lhs, const Object& rhs)
   {
     return (lhs.a + lhs.b) <= (rhs.a + rhs.b);
   }
 
   //***********************************
-  bool operator >=(const Test& lhs, const Test& rhs)
+  bool constexpr operator >=(const Object& lhs, const Object& rhs)
   {
     return (lhs.a + lhs.b) >= (rhs.a + rhs.b);
   }
 
+  //***********************************
+  bool constexpr operator ==(const Object& lhs, const Object& rhs)
+  {
+    return (lhs.a + lhs.b) == (rhs.a + rhs.b);
+  }
+
+  //***********************************
+  bool constexpr operator !=(const Object& lhs, const Object& rhs)
+  {
+    return (lhs.a + lhs.b) != (rhs.a + rhs.b);
+  }
+
   //***********************************
   struct LessTest
   {
-    bool operator()(const Test& lhs, const Test& rhs) const
+    bool constexpr operator()(const Object& lhs, const Object& rhs) const
     {
       return (lhs.a + lhs.b) < (rhs.a + rhs.b);
     }
   };
 
-  typedef etl::compare<Test, LessTest> CompareTest;
+  typedef etl::compare<Object, LessTest> CompareTest;
 
   SUITE(test_compare)
   {
     //*************************************************************************
     TEST(test_lt)
-    { 
-      CHECK_EQUAL(a < b,   (CompareInt::lt(a, b)));
-      CHECK_EQUAL(b < a,   (CompareInt::lt(b, a)));
-      CHECK_EQUAL(a < a,   (CompareInt::lt(a, a)));
+    {
+      CHECK_EQUAL(a < b, (CompareInt::lt(a, b)));
+      CHECK_EQUAL(b < a, (CompareInt::lt(b, a)));
+      CHECK_EQUAL(a < a, (CompareInt::lt(a, a)));
       CHECK_EQUAL(ta < tb, (CompareTest::lt(ta, tb)));
       CHECK_EQUAL(tb < ta, (CompareTest::lt(tb, ta)));
       CHECK_EQUAL(ta < ta, (CompareTest::lt(ta, ta)));
@@ -97,9 +109,9 @@ namespace
     //*************************************************************************
     TEST(test_lte)
     {
-      CHECK_EQUAL(a <= b,   (CompareInt::lte(a, b)));
-      CHECK_EQUAL(b <= a,   (CompareInt::lte(b, a)));
-      CHECK_EQUAL(a <= a,   (CompareInt::lte(a, a)));
+      CHECK_EQUAL(a <= b, (CompareInt::lte(a, b)));
+      CHECK_EQUAL(b <= a, (CompareInt::lte(b, a)));
+      CHECK_EQUAL(a <= a, (CompareInt::lte(a, a)));
       CHECK_EQUAL(ta <= tb, (CompareTest::lte(ta, tb)));
       CHECK_EQUAL(tb <= ta, (CompareTest::lte(tb, ta)));
       CHECK_EQUAL(ta <= ta, (CompareTest::lte(ta, ta)));
@@ -108,9 +120,9 @@ namespace
     //*************************************************************************
     TEST(test_gt)
     {
-      CHECK_EQUAL(a > b,   (CompareInt::gt(a, b)));
-      CHECK_EQUAL(b > a,   (CompareInt::gt(b, a)));
-      CHECK_EQUAL(a > a,   (CompareInt::gt(a, a)));
+      CHECK_EQUAL(a > b, (CompareInt::gt(a, b)));
+      CHECK_EQUAL(b > a, (CompareInt::gt(b, a)));
+      CHECK_EQUAL(a > a, (CompareInt::gt(a, a)));
       CHECK_EQUAL(ta > tb, (CompareTest::gt(ta, tb)));
       CHECK_EQUAL(tb > ta, (CompareTest::gt(tb, ta)));
       CHECK_EQUAL(ta > ta, (CompareTest::gt(ta, ta)));
@@ -119,12 +131,65 @@ namespace
     //*************************************************************************
     TEST(test_gte)
     {
-      CHECK_EQUAL(a >= b,   (CompareInt::gte(a, b)));
-      CHECK_EQUAL(b >= a,   (CompareInt::gte(b, a)));
-      CHECK_EQUAL(a >= a,   (CompareInt::gte(a, a)));
+      CHECK_EQUAL(a >= b, (CompareInt::gte(a, b)));
+      CHECK_EQUAL(b >= a, (CompareInt::gte(b, a)));
+      CHECK_EQUAL(a >= a, (CompareInt::gte(a, a)));
       CHECK_EQUAL(ta >= tb, (CompareTest::gte(ta, tb)));
       CHECK_EQUAL(tb >= ta, (CompareTest::gte(tb, ta)));
       CHECK_EQUAL(ta >= ta, (CompareTest::gte(ta, ta)));
     }
+
+    //*************************************************************************
+    TEST(test_eq)
+    {
+      CHECK_EQUAL(a == b, (CompareInt::eq(a, b)));
+      CHECK_EQUAL(b == a, (CompareInt::eq(b, a)));
+      CHECK_EQUAL(a == a, (CompareInt::eq(a, a)));
+      CHECK_EQUAL(ta == tb, (CompareTest::eq(ta, tb)));
+      CHECK_EQUAL(tb == ta, (CompareTest::eq(tb, ta)));
+      CHECK_EQUAL(ta == ta, (CompareTest::eq(ta, ta)));
+    }
+
+    //*************************************************************************
+    TEST(test_ne)
+    {
+      CHECK_EQUAL(a != b, (CompareInt::ne(a, b)));
+      CHECK_EQUAL(b != a, (CompareInt::ne(b, a)));
+      CHECK_EQUAL(a != a, (CompareInt::ne(a, a)));
+      CHECK_EQUAL(ta != tb, (CompareTest::ne(ta, tb)));
+      CHECK_EQUAL(tb != ta, (CompareTest::ne(tb, ta)));
+      CHECK_EQUAL(ta != ta, (CompareTest::ne(ta, ta)));
+    }
+
+    //*************************************************************************
+    TEST(test_cmp)
+    {
+      CHECK_EQUAL(CompareInt::Less, (CompareInt::cmp(2, 4)));
+      CHECK_EQUAL(CompareInt::Greater, (CompareInt::cmp(4, 2)));
+      CHECK_EQUAL(CompareInt::Equal, (CompareInt::cmp(0, 0)));
+      CHECK_EQUAL(CompareTest::Less, (CompareTest::cmp(Object{ 0, 1 }, Object{ 2, 4 })));
+      CHECK_EQUAL(CompareTest::Greater, (CompareTest::cmp(Object{ 2, 4 }, Object{ 0, 1 })));
+      CHECK_EQUAL(CompareTest::Equal, (CompareTest::cmp(Object{ 2, 4 }, Object{ 2, 4 })));
+    }
+
+    //*************************************************************************
+    TEST(test_constexpr_cmp)
+    {
+      constexpr int cmp_less    = CompareInt::cmp(2, 4);
+      constexpr int cmp_greater = CompareInt::cmp(4, 2);
+      constexpr int cmp_equal   = CompareInt::cmp(0, 0);
+
+      constexpr int cmp_test_less    = CompareTest::cmp(Object{ 0, 1 }, Object{ 2, 4 });
+      constexpr int cmp_test_greater = CompareTest::cmp(Object{ 2, 4 }, Object{ 0, 1 });
+      constexpr int cmp_test_equal   = CompareTest::cmp(Object{ 2, 4 }, Object{ 2, 4 });
+
+      CHECK_EQUAL(CompareInt::Less,    cmp_less);
+      CHECK_EQUAL(CompareInt::Greater, cmp_greater);
+      CHECK_EQUAL(CompareInt::Equal,   cmp_equal);
+
+      CHECK_EQUAL(CompareInt::Less,    cmp_test_less);
+      CHECK_EQUAL(CompareInt::Greater, cmp_test_greater);
+      CHECK_EQUAL(CompareInt::Equal,   cmp_test_equal);
+    }
   };
 }
diff --git a/test/test_crc8_j1850.cpp b/test/test_crc8_j1850.cpp
new file mode 100644
index 00000000..1b50b14a
--- /dev/null
+++ b/test/test_crc8_j1850.cpp
@@ -0,0 +1,263 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2021 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#include "unit_test_framework.h"
+
+#include <iterator>
+#include <string>
+#include <vector>
+#include <stdint.h>
+
+#include "etl/crc8_j1850.h"
+
+//*****************************************************************************
+// The results for these tests were created from http://www.sunshine2k.de/coding/javascript/crc/crc_js.html
+//*****************************************************************************
+
+namespace
+{
+  SUITE(test_crc_crc8_j1850)
+  {
+    //*************************************************************************
+    // Table size 4
+    //*************************************************************************
+    TEST(test_crc8_j1850_4_constructor)
+    {
+      std::string data("123456789");
+
+      uint8_t crc = etl::crc8_j1850_t4(data.begin(), data.end());
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_4_add_values)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_t4 crc_calculator;
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        crc_calculator.add(data[i]);
+      }
+
+      uint8_t crc = crc_calculator;
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_4_add_range)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_t4 crc_calculator;
+
+      crc_calculator.add(data.begin(), data.end());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j18_50_4_add_range_via_iterator)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_t4 crc_calculator;
+
+      std::copy(data.begin(), data.end(), crc_calculator.input());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_4_add_range_endian)
+    {
+      std::vector<uint8_t>  data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
+      std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
+      std::vector<uint8_t>  data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
+
+      uint8_t crc1 = etl::crc8_j1850_t4(data1.begin(), data1.end());
+      uint8_t crc2 = etl::crc8_j1850_t4((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
+      CHECK_EQUAL(int(crc1), int(crc2));
+
+      uint8_t crc3 = etl::crc8_j1850_t4(data3.rbegin(), data3.rend());
+      CHECK_EQUAL(int(crc1), int(crc3));
+    }
+
+    //*************************************************************************
+    // Table size 16
+    //*************************************************************************
+    TEST(test_crc8_j1850_16_constructor)
+    {
+      std::string data("123456789");
+
+      uint8_t crc = etl::crc8_j1850_t16(data.begin(), data.end());
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_16_add_values)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_t16 crc_calculator;
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        crc_calculator.add(data[i]);
+      }
+
+      uint8_t crc = crc_calculator;
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_16_add_range)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_t16 crc_calculator;
+
+      crc_calculator.add(data.begin(), data.end());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_16_add_range_via_iterator)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_t16 crc_calculator;
+
+      std::copy(data.begin(), data.end(), crc_calculator.input());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_16_add_range_endian)
+    {
+      std::vector<uint8_t>  data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
+      std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
+      std::vector<uint8_t>  data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
+
+      uint8_t crc1 = etl::crc8_j1850_t16(data1.begin(), data1.end());
+      uint8_t crc2 = etl::crc8_j1850_t16((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
+      CHECK_EQUAL(int(crc1), int(crc2));
+
+      uint8_t crc3 = etl::crc8_j1850_t16(data3.rbegin(), data3.rend());
+      CHECK_EQUAL(int(crc1), int(crc3));
+    }
+
+    //*************************************************************************
+    // Table size 256
+    //*************************************************************************
+    TEST(test_crc8_j1850_256_constructor)
+    {
+      std::string data("123456789");
+
+      uint8_t crc = etl::crc8_j1850(data.begin(), data.end());
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_256_add_values)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850 crc_calculator;
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        crc_calculator.add(data[i]);
+      }
+
+      uint8_t crc = crc_calculator;
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_256_add_range)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850 crc_calculator;
+
+      crc_calculator.add(data.begin(), data.end());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_256_add_range_via_iterator)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850 crc_calculator;
+
+      std::copy(data.begin(), data.end(), crc_calculator.input());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x4BU, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_256_add_range_endian)
+    {
+      std::vector<uint8_t>  data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
+      std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
+      std::vector<uint8_t>  data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
+
+      uint8_t crc1 = etl::crc8_j1850(data1.begin(), data1.end());
+      uint8_t crc2 = etl::crc8_j1850((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
+      CHECK_EQUAL(int(crc1), int(crc2));
+
+      uint8_t crc3 = etl::crc8_j1850(data3.rbegin(), data3.rend());
+      CHECK_EQUAL(int(crc1), int(crc3));
+    }
+  };
+}
+
diff --git a/test/test_crc8_j1850_zero.cpp b/test/test_crc8_j1850_zero.cpp
new file mode 100644
index 00000000..3ab0bae3
--- /dev/null
+++ b/test/test_crc8_j1850_zero.cpp
@@ -0,0 +1,263 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2021 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#include "unit_test_framework.h"
+
+#include <iterator>
+#include <string>
+#include <vector>
+#include <stdint.h>
+
+#include "etl/crc8_j1850_zero.h"
+
+//*****************************************************************************
+// The results for these tests were created from http://www.sunshine2k.de/coding/javascript/crc/crc_js.html
+//*****************************************************************************
+
+namespace
+{
+  SUITE(test_crc_crc8_j1850_zero)
+  {
+    //*************************************************************************
+    // Table size 4
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_4_constructor)
+    {
+      std::string data("123456789");
+
+      uint8_t crc = etl::crc8_j1850_zero_t4(data.begin(), data.end());
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_4_add_values)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_zero_t4 crc_calculator;
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        crc_calculator.add(data[i]);
+      }
+
+      uint8_t crc = crc_calculator;
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_4_add_range)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_zero_t4 crc_calculator;
+
+      crc_calculator.add(data.begin(), data.end());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_4_add_range_via_iterator)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_zero_t4 crc_calculator;
+
+      std::copy(data.begin(), data.end(), crc_calculator.input());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_4_add_range_endian)
+    {
+      std::vector<uint8_t>  data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
+      std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
+      std::vector<uint8_t>  data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
+
+      uint8_t crc1 = etl::crc8_j1850_zero_t4(data1.begin(), data1.end());
+      uint8_t crc2 = etl::crc8_j1850_zero_t4((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
+      CHECK_EQUAL(int(crc1), int(crc2));
+
+      uint8_t crc3 = etl::crc8_j1850_zero_t4(data3.rbegin(), data3.rend());
+      CHECK_EQUAL(int(crc1), int(crc3));
+    }
+
+    //*************************************************************************
+    // Table size 16
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_16_constructor)
+    {
+      std::string data("123456789");
+
+      uint8_t crc = etl::crc8_j1850_zero_t16(data.begin(), data.end());
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_16_add_values)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_zero_t16 crc_calculator;
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        crc_calculator.add(data[i]);
+      }
+
+      uint8_t crc = crc_calculator;
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_16_add_range)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_zero_t16 crc_calculator;
+
+      crc_calculator.add(data.begin(), data.end());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_16_add_range_via_iterator)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_zero_t16 crc_calculator;
+
+      std::copy(data.begin(), data.end(), crc_calculator.input());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_16_add_range_endian)
+    {
+      std::vector<uint8_t>  data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
+      std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
+      std::vector<uint8_t>  data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
+
+      uint8_t crc1 = etl::crc8_j1850_zero_t16(data1.begin(), data1.end());
+      uint8_t crc2 = etl::crc8_j1850_zero_t16((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
+      CHECK_EQUAL(int(crc1), int(crc2));
+
+      uint8_t crc3 = etl::crc8_j1850_zero_t16(data3.rbegin(), data3.rend());
+      CHECK_EQUAL(int(crc1), int(crc3));
+    }
+
+    //*************************************************************************
+    // Table size 256
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_256_constructor)
+    {
+      std::string data("123456789");
+
+      uint8_t crc = etl::crc8_j1850_zero(data.begin(), data.end());
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_256_add_values)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_zero crc_calculator;
+
+      for (size_t i = 0UL; i < data.size(); ++i)
+      {
+        crc_calculator.add(data[i]);
+      }
+
+      uint8_t crc = crc_calculator;
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_256_add_range)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_zero crc_calculator;
+
+      crc_calculator.add(data.begin(), data.end());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_256_add_range_via_iterator)
+    {
+      std::string data("123456789");
+
+      etl::crc8_j1850_zero crc_calculator;
+
+      std::copy(data.begin(), data.end(), crc_calculator.input());
+
+      uint8_t crc = crc_calculator.value();
+
+      CHECK_EQUAL(0x37U, int(crc));
+    }
+
+    //*************************************************************************
+    TEST(test_crc8_j1850_zero_256_add_range_endian)
+    {
+      std::vector<uint8_t>  data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
+      std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
+      std::vector<uint8_t>  data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
+
+      uint8_t crc1 = etl::crc8_j1850_zero(data1.begin(), data1.end());
+      uint8_t crc2 = etl::crc8_j1850_zero((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
+      CHECK_EQUAL(int(crc1), int(crc2));
+
+      uint8_t crc3 = etl::crc8_j1850_zero(data3.rbegin(), data3.rend());
+      CHECK_EQUAL(int(crc1), int(crc3));
+    }
+  };
+}
+
diff --git a/test/test_cyclic_value.cpp b/test/test_cyclic_value.cpp
index a15d1699..face6086 100644
--- a/test/test_cyclic_value.cpp
+++ b/test/test_cyclic_value.cpp
@@ -75,7 +75,14 @@ namespace
     //*************************************************************************
     TEST(test_set_compile_time)
     {
-      etl::cyclic_value<int, 2, 7> value;
+      using CV = etl::cyclic_value<int, 2, 7>;
+
+      CV value;
+
+      CHECK_EQUAL(2, value.first());
+      CHECK_EQUAL(7, value.last());
+      CHECK_EQUAL(2, CV::first());
+      CHECK_EQUAL(7, CV::last());
 
       value.set(5);
       CHECK_EQUAL(5, value.get());
diff --git a/test/test_delegate.cpp b/test/test_delegate.cpp
index 63ff2648..e3fe0b31 100644
--- a/test/test_delegate.cpp
+++ b/test/test_delegate.cpp
@@ -71,7 +71,7 @@ namespace
   bool parameter_correct = false;
 
   //*****************************************************************************
-  // Test data structure.
+  // Object data structure.
   //*****************************************************************************
   struct Data
   {
@@ -79,7 +79,7 @@ namespace
   };
 
   //*****************************************************************************
-  // Test moveable only data structure.
+  // Object moveable only data structure.
   //*****************************************************************************
   struct MoveableOnlyData
   {
@@ -161,7 +161,7 @@ namespace
   //*****************************************************************************
   // The test class with member functions.
   //*****************************************************************************
-  class Test
+  class Object
   {
   public:
 
@@ -240,8 +240,8 @@ namespace
     return a * 2;
   }
 
-  Test test_static;
-  const Test const_test_static;
+  Object object_static;
+  const Object const_object_static;
 }
 
 namespace
@@ -437,9 +437,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void)
     {
-      Test test;
+      Object object;
 
-      etl::delegate<void(void)> d(test);
+      etl::delegate<void(void)> d(object);
 
       d();
 
@@ -449,9 +449,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void_create)
     {
-      Test test;
+      Object object;
 
-      auto d = etl::delegate<void(void)>::create(test);
+      auto d = etl::delegate<void(void)>::create(object);
 
       d();
 
@@ -462,9 +462,9 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_operator_void_create_constexpr)
     {
-      static Test test;
+      static Object object;
 
-      constexpr auto d = etl::delegate<void(void)>::create(test);
+      constexpr auto d = etl::delegate<void(void)>::create(object);
 
       d();
 
@@ -475,9 +475,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void_const)
     {
-      const Test test;
+      const Object object;
 
-      etl::delegate<void(void)> d(test);
+      etl::delegate<void(void)> d(object);
 
       d();
 
@@ -488,7 +488,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void_compile_time)
     {
-      auto d = etl::delegate<void(void)>::create<Test, test_static>();
+      auto d = etl::delegate<void(void)>::create<Object, object_static>();
 
       d();
 
@@ -499,7 +499,7 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_operator_void_compile_time_constexpr)
     {
-      constexpr auto d = etl::delegate<void(void)>::create<Test, test_static>();
+      constexpr auto d = etl::delegate<void(void)>::create<Object, object_static>();
 
       d();
 
@@ -510,7 +510,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void_compile_time_const)
     {
-      auto d = etl::delegate<void(void)>::create<const Test, const_test_static>();
+      auto d = etl::delegate<void(void)>::create<const Object, const_object_static>();
 
       d();
 
@@ -521,7 +521,7 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_operator_void_compile_time_const_constexpr)
     {
-      constexpr auto d = etl::delegate<void(void)>::create<const Test, const_test_static>();
+      constexpr auto d = etl::delegate<void(void)>::create<const Object, const_object_static>();
 
       d();
 
@@ -533,11 +533,11 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_assignment_member_operator_void)
     {
-      Test test;
+      Object object;
 
       etl::delegate<void(void)> d;
 
-      d = test;
+      d = object;
 
       d();
 
@@ -547,9 +547,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void)
     {
-      Test test;
+      Object object;
 
-      auto d = etl::delegate<void(void)>::create<Test, &Test::member_void>(test);
+      auto d = etl::delegate<void(void)>::create<Object, &Object::member_void>(object);
 
       d();
 
@@ -560,9 +560,9 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_void_constexpr)
     {
-      static Test test;
+      static Object object;
 
-      constexpr auto d = etl::delegate<void(void)>::create<Test, &Test::member_void>(test);
+      constexpr auto d = etl::delegate<void(void)>::create<Object, &Object::member_void>(object);
 
       d();
 
@@ -573,9 +573,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void_const)
     {
-      const Test test;
+      const Object object;
 
-      auto d = etl::delegate<void(void)>::create<Test, &Test::member_void_const>(test);
+      auto d = etl::delegate<void(void)>::create<Object, &Object::member_void_const>(object);
 
       d();
 
@@ -586,9 +586,9 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_void_const_constexpr)
     {
-      static const Test test;
+      static const Object object;
 
-      constexpr auto d = etl::delegate<void(void)>::create<Test, &Test::member_void_const>(test);
+      constexpr auto d = etl::delegate<void(void)>::create<Object, &Object::member_void_const>(object);
 
       d();
 
@@ -599,9 +599,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int)
     {
-      Test test;
+      Object object;
 
-      auto d = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test);
+      auto d = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(object);
 
       d(VALUE1, VALUE2);
 
@@ -613,9 +613,9 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_int_constexpr)
     {
-      static Test test;
+      static Object object;
 
-      constexpr auto d = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test);
+      constexpr auto d = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(object);
 
       d(VALUE1, VALUE2);
 
@@ -627,9 +627,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int_const)
     {
-      const Test test;
+      const Object object;
 
-      auto d = etl::delegate<void(int, int)>::create<Test, &Test::member_int_const>(test);
+      auto d = etl::delegate<void(int, int)>::create<Object, &Object::member_int_const>(object);
 
       d(VALUE1, VALUE2);
 
@@ -641,9 +641,9 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_int_const_constexpr)
     {
-      static const Test test;
+      static const Object object;
 
-      constexpr auto d = etl::delegate<void(int, int)>::create<Test, &Test::member_int_const>(test);
+      constexpr auto d = etl::delegate<void(int, int)>::create<Object, &Object::member_int_const>(object);
 
       d(VALUE1, VALUE2);
 
@@ -655,8 +655,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference)
     {
-      Test test;
-      auto d = etl::delegate<void(const Data&, int)>::create<Test, &Test::member_reference>(test);
+      Object object;
+      auto d = etl::delegate<void(const Data&, int)>::create<Object, &Object::member_reference>(object);
 
       Data data;
       data.d = VALUE1;
@@ -671,8 +671,8 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_reference_constexpr)
     {
-      static Test test;
-      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Test, &Test::member_reference>(test);
+      static Object object;
+      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Object, &Object::member_reference>(object);
 
       Data data;
       data.d = VALUE1;
@@ -687,8 +687,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference_const)
     {
-      const Test test;
-      auto d = etl::delegate<void(const Data&, int)>::create<Test, &Test::member_reference_const>(test);
+      const Object object;
+      auto d = etl::delegate<void(const Data&, int)>::create<Object, &Object::member_reference_const>(object);
 
       Data data;
       data.d = VALUE1;
@@ -703,8 +703,8 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_reference_const_constexpr)
     {
-      static const Test test;
-      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Test, &Test::member_reference_const>(test);
+      static const Object object;
+      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Object, &Object::member_reference_const>(object);
 
       Data data;
       data.d = VALUE1;
@@ -719,8 +719,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_moveableonly)
     {
-      Test test;
-      auto d = etl::delegate<void(MoveableOnlyData&&)>::create<Test, &Test::member_moveableonly>(test);
+      Object object;
+      auto d = etl::delegate<void(MoveableOnlyData&&)>::create<Object, &Object::member_moveableonly>(object);
 
       MoveableOnlyData data;
       data.d = VALUE1;
@@ -735,8 +735,8 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_moveableonly_constexpr)
     {
-      static Test test;
-      constexpr auto d = etl::delegate<void(MoveableOnlyData&&)>::create<Test, &Test::member_moveableonly>(test);
+      static Object object;
+      constexpr auto d = etl::delegate<void(MoveableOnlyData&&)>::create<Object, &Object::member_moveableonly>(object);
 
       MoveableOnlyData data;
       data.d = VALUE1;
@@ -751,7 +751,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_static)
     {
-      auto d = etl::delegate<void(const Data&, int)>::create<Test::member_static>();
+      auto d = etl::delegate<void(const Data&, int)>::create<Object::member_static>();
 
       Data data;
       data.d = VALUE1;
@@ -766,7 +766,7 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_static_constexpr)
     {
-      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Test::member_static>();
+      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Object::member_static>();
 
       Data data;
       data.d = VALUE1;
@@ -782,7 +782,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void_compile_time)
     {
-      auto d = etl::delegate<void(void)>::create<Test, test_static, &Test::member_void>();
+      auto d = etl::delegate<void(void)>::create<Object, object_static, &Object::member_void>();
 
       d();
 
@@ -793,7 +793,7 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_void_compile_time_constexpr)
     {
-      constexpr auto d = etl::delegate<void(void)>::create<Test, test_static, &Test::member_void>();
+      constexpr auto d = etl::delegate<void(void)>::create<Object, object_static, &Object::member_void>();
 
       d();
 
@@ -804,7 +804,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void_const_compile_time)
     {
-      auto d = etl::delegate<void(void)>::create<Test, const_test_static, &Test::member_void_const>();
+      auto d = etl::delegate<void(void)>::create<Object, const_object_static, &Object::member_void_const>();
 
       d();
 
@@ -815,7 +815,7 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_void_const_compile_time_constexpr)
     {
-      constexpr auto d = etl::delegate<void(void)>::create<Test, const_test_static, &Test::member_void_const>();
+      constexpr auto d = etl::delegate<void(void)>::create<Object, const_object_static, &Object::member_void_const>();
 
       d();
 
@@ -826,7 +826,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int_compile_time)
     {
-      auto d = etl::delegate<void(int, int)>::create<Test, test_static, &Test::member_int>();
+      auto d = etl::delegate<void(int, int)>::create<Object, object_static, &Object::member_int>();
 
       d(VALUE1, VALUE2);
 
@@ -838,7 +838,7 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_int_compile_time_constexpr)
     {
-      constexpr auto d = etl::delegate<void(int, int)>::create<Test, test_static, &Test::member_int>();
+      constexpr auto d = etl::delegate<void(int, int)>::create<Object, object_static, &Object::member_int>();
 
       d(VALUE1, VALUE2);
 
@@ -850,7 +850,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int_const_compile_time)
     {
-      auto d = etl::delegate<void(int, int)>::create<Test, const_test_static, &Test::member_int_const>();
+      auto d = etl::delegate<void(int, int)>::create<Object, const_object_static, &Object::member_int_const>();
 
       d(VALUE1, VALUE2);
 
@@ -862,7 +862,7 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_int_const_compile_time_constexpr)
     {
-      constexpr auto d = etl::delegate<void(int, int)>::create<Test, const_test_static, &Test::member_int_const>();
+      constexpr auto d = etl::delegate<void(int, int)>::create<Object, const_object_static, &Object::member_int_const>();
 
       d(VALUE1, VALUE2);
 
@@ -874,7 +874,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference_compile_time)
     {
-      auto d = etl::delegate<void(const Data&, int)>::create<Test, test_static, &Test::member_reference>();
+      auto d = etl::delegate<void(const Data&, int)>::create<Object, object_static, &Object::member_reference>();
 
       Data data;
       data.d = VALUE1;
@@ -889,7 +889,7 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_reference_compile_time_constexpr)
     {
-      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Test, test_static, &Test::member_reference>();
+      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Object, object_static, &Object::member_reference>();
 
       Data data;
       data.d = VALUE1;
@@ -904,7 +904,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference_const_compile_time)
     {
-      auto d = etl::delegate<void(const Data&, int)>::create<Test, const_test_static, &Test::member_reference_const>();
+      auto d = etl::delegate<void(const Data&, int)>::create<Object, const_object_static, &Object::member_reference_const>();
 
       Data data;
       data.d = VALUE1;
@@ -919,7 +919,7 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_member_reference_const_compile_time_constexpr)
     {
-      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Test, const_test_static, &Test::member_reference_const>();
+      constexpr auto d = etl::delegate<void(const Data&, int)>::create<Object, const_object_static, &Object::member_reference_const>();
 
       Data data;
       data.d = VALUE1;
@@ -960,10 +960,10 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_set_member_reference)
     {
-      Test test;
+      Object object;
       etl::delegate<void(const Data&, int)> d;
       
-      d.set<Test, &Test::member_reference>(test);
+      d.set<Object, &Object::member_reference>(object);
 
       Data data;
       data.d = VALUE1;
@@ -977,10 +977,10 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_set_const_member_reference)
     {
-      Test test;
+      Object object;
       etl::delegate<void(const Data&, int)> d;
 
-      d.set<Test, &Test::member_reference_const>(test);
+      d.set<Object, &Object::member_reference_const>(object);
 
       Data data;
       data.d = VALUE1;
@@ -996,7 +996,7 @@ namespace
     {
       etl::delegate<void(const Data&, int)> d;
 
-      d.set<Test, test_static, &Test::member_reference>();
+      d.set<Object, object_static, &Object::member_reference>();
 
       Data data;
       data.d = VALUE1;
@@ -1012,7 +1012,7 @@ namespace
     {
       etl::delegate<void(const Data&, int)> d;
 
-      d.set<Test, const_test_static, &Test::member_reference_const>();
+      d.set<Object, const_object_static, &Object::member_reference_const>();
 
       Data data;
       data.d = VALUE1;
@@ -1027,9 +1027,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_copy_construct)
     {
-      Test test;
+      Object object;
 
-      auto d1 = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test);
+      auto d1 = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(object);
       auto d2(d1);
 
       d2(VALUE1, VALUE2);
@@ -1042,9 +1042,9 @@ namespace
 #if ETL_USING_CPP14
     TEST_FIXTURE(SetupFixture, test_copy_construct_constexpr)
     {
-      static Test test;
+      static Object object;
 
-      constexpr auto d1 = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test);
+      constexpr auto d1 = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(object);
       constexpr auto d2(d1);
 
       d2(VALUE1, VALUE2);
@@ -1057,9 +1057,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_assignment)
     {
-      Test test;
+      Object object;
 
-      auto d1 = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test);
+      auto d1 = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(object);
       etl::delegate<void(int, int)> d2;
 
       d2 = d1;
@@ -1073,9 +1073,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_delegate_equal)
     {
-      Test test;
+      Object object;
 
-      auto d1 = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test);
+      auto d1 = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(object);
       auto d2 = d1;
 
       CHECK(d1 == d2);
@@ -1084,10 +1084,10 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_delegate_not_equal)
     {
-      Test test;
+      Object object;
 
-      auto d1 = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test);
-      auto d2 = etl::delegate<void(int, int)>::create<Test, &Test::member_int_const>(test);;
+      auto d1 = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(object);
+      auto d2 = etl::delegate<void(int, int)>::create<Object, &Object::member_int_const>(object);;
 
       CHECK(d1 != d2);
     }
@@ -1205,12 +1205,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_delegate_identification)
     {
-      Test test1;
-      Test test2;
+      Object test1;
+      Object test2;
 
       auto d1 = etl::delegate<void(int, int)>::create<free_int>();
-      auto d2 = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test1);
-      auto d3 = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test2);
+      auto d2 = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(test1);
+      auto d3 = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(test2);
 
       etl::delegate<void(int, int)> d4;
 
@@ -1241,7 +1241,7 @@ namespace
       CHECK(*itr != d2);
       CHECK(*itr == d3);
 
-      d4 = etl::delegate<void(int, int)>::create<Test, &Test::member_int>(test2); // Same as d3
+      d4 = etl::delegate<void(int, int)>::create<Object, &Object::member_int>(test2); // Same as d3
       itr = std::find(delegate_list.begin(), delegate_list.end(), d4);
       CHECK(*itr != d1);
       CHECK(*itr != d2);
diff --git a/test/test_delegate_cpp03.cpp b/test/test_delegate_cpp03.cpp
index 3156cb78..10be5d4d 100644
--- a/test/test_delegate_cpp03.cpp
+++ b/test/test_delegate_cpp03.cpp
@@ -70,7 +70,7 @@ namespace
   bool parameter_correct = false;
 
   //*****************************************************************************
-  // Test data structure.
+  // Object data structure.
   //*****************************************************************************
   struct Data
   {
@@ -137,7 +137,7 @@ namespace
   //*****************************************************************************
   // The test class with member functions.
   //*****************************************************************************
-  class Test
+  class Object
   {
   public:
 
@@ -208,8 +208,8 @@ namespace
     return a * 2;
   }
 
-  Test test_static;
-  const Test const_test_static;
+  Object test_static;
+  const Object const_test_static;
 }
 
 namespace
@@ -297,9 +297,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void)
     {
-      Test test;
+      Object object;
 
-      etl_cpp03::delegate<void(void)> d(test);
+      etl_cpp03::delegate<void(void)> d(object);
 
       d();
 
@@ -309,9 +309,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void_create)
     {
-      Test test;
+      Object object;
 
-      auto d = etl_cpp03::delegate<void(void)>::create(test);
+      auto d = etl_cpp03::delegate<void(void)>::create(object);
 
       d();
 
@@ -321,9 +321,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void_const)
     {
-      const Test test;
+      const Object object;
 
-      etl_cpp03::delegate<void(void)> d(test);
+      etl_cpp03::delegate<void(void)> d(object);
 
       d();
 
@@ -334,7 +334,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void_compile_time)
     {
-      auto d = etl_cpp03::delegate<void(void)>::create<Test, test_static>();
+      auto d = etl_cpp03::delegate<void(void)>::create<Object, test_static>();
 
       d();
 
@@ -344,7 +344,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_operator_void_compile_time_const)
     {
-      auto d = etl_cpp03::delegate<void(void)>::create<const Test, const_test_static>();
+      auto d = etl_cpp03::delegate<void(void)>::create<const Object, const_test_static>();
 
       d();
 
@@ -355,11 +355,11 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_assignment_member_operator_void)
     {
-      Test test;
+      Object object;
 
       etl_cpp03::delegate<void(void)> d;
 
-      d = test;
+      d = object;
 
       d();
 
@@ -369,9 +369,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void)
     {
-      Test test;
+      Object object;
 
-      auto d = etl_cpp03::delegate<void(void)>::create<Test, &Test::member_void>(test);
+      auto d = etl_cpp03::delegate<void(void)>::create<Object, &Object::member_void>(object);
 
       d();
 
@@ -381,9 +381,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void_const)
     {
-      const Test test;
+      const Object object;
 
-      auto d = etl_cpp03::delegate<void(void)>::create<Test, &Test::member_void_const>(test);
+      auto d = etl_cpp03::delegate<void(void)>::create<Object, &Object::member_void_const>(object);
 
       d();
 
@@ -393,9 +393,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int)
     {
-      Test test;
+      Object object;
 
-      auto d = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int>(test);
+      auto d = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int>(object);
 
       d(VALUE1);
 
@@ -406,9 +406,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int_const)
     {
-      const Test test;
+      const Object object;
 
-      auto d = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int_const>(test);
+      auto d = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int_const>(object);
 
       d(VALUE1);
 
@@ -419,8 +419,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference)
     {
-      Test test;
-      auto d = etl_cpp03::delegate<void(const Data&)>::create<Test, &Test::member_reference>(test);
+      Object object;
+      auto d = etl_cpp03::delegate<void(const Data&)>::create<Object, &Object::member_reference>(object);
 
       Data data;
       data.d = VALUE1;
@@ -434,8 +434,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference_const)
     {
-      const Test test;
-      auto d = etl_cpp03::delegate<void(const Data&)>::create<Test, &Test::member_reference_const>(test);
+      const Object object;
+      auto d = etl_cpp03::delegate<void(const Data&)>::create<Object, &Object::member_reference_const>(object);
 
       Data data;
       data.d = VALUE1;
@@ -449,7 +449,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_static)
     {
-      auto d = etl_cpp03::delegate<void(const Data&)>::create<Test::member_static>();
+      auto d = etl_cpp03::delegate<void(const Data&)>::create<Object::member_static>();
 
       Data data;
       data.d = VALUE1;
@@ -464,7 +464,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void_compile_time)
     {
-      auto d = etl_cpp03::delegate<void(void)>::create<Test, test_static, &Test::member_void>();
+      auto d = etl_cpp03::delegate<void(void)>::create<Object, test_static, &Object::member_void>();
 
       d();
 
@@ -474,7 +474,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void_const_compile_time)
     {
-      auto d = etl_cpp03::delegate<void(void)>::create<Test, const_test_static, &Test::member_void_const>();
+      auto d = etl_cpp03::delegate<void(void)>::create<Object, const_test_static, &Object::member_void_const>();
 
       d();
 
@@ -484,7 +484,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int_compile_time)
     {
-      auto d = etl_cpp03::delegate<void(int)>::create<Test, test_static, &Test::member_int>();
+      auto d = etl_cpp03::delegate<void(int)>::create<Object, test_static, &Object::member_int>();
 
       d(VALUE1);
 
@@ -495,7 +495,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int_const_compile_time)
     {
-      auto d = etl_cpp03::delegate<void(int)>::create<Test, const_test_static, &Test::member_int_const>();
+      auto d = etl_cpp03::delegate<void(int)>::create<Object, const_test_static, &Object::member_int_const>();
 
       d(VALUE1);
 
@@ -506,7 +506,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference_compile_time)
     {
-      auto d = etl_cpp03::delegate<void(const Data&)>::create<Test, test_static, &Test::member_reference>();
+      auto d = etl_cpp03::delegate<void(const Data&)>::create<Object, test_static, &Object::member_reference>();
 
       Data data;
       data.d = VALUE1;
@@ -520,7 +520,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference_const_compile_time)
     {
-      auto d = etl_cpp03::delegate<void(const Data&)>::create<Test, const_test_static, &Test::member_reference_const>();
+      auto d = etl_cpp03::delegate<void(const Data&)>::create<Object, const_test_static, &Object::member_reference_const>();
 
       Data data;
       data.d = VALUE1;
@@ -560,10 +560,10 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_set_member_reference)
     {
-      Test test;
+      Object object;
       etl_cpp03::delegate<void(const Data&)> d;
       
-      d.set<Test, &Test::member_reference>(test);
+      d.set<Object, &Object::member_reference>(object);
 
       Data data;
       data.d = VALUE1;
@@ -577,10 +577,10 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_set_const_member_reference)
     {
-      Test test;
+      Object object;
       etl_cpp03::delegate<void(const Data&)> d;
 
-      d.set<Test, &Test::member_reference_const>(test);
+      d.set<Object, &Object::member_reference_const>(object);
 
       Data data;
       data.d = VALUE1;
@@ -596,7 +596,7 @@ namespace
     {
       etl_cpp03::delegate<void(const Data&)> d;
 
-      d.set<Test, test_static, &Test::member_reference>();
+      d.set<Object, test_static, &Object::member_reference>();
 
       Data data;
       data.d = VALUE1;
@@ -612,7 +612,7 @@ namespace
     {
       etl_cpp03::delegate<void(const Data&)> d;
 
-      d.set<Test, const_test_static, &Test::member_reference_const>();
+      d.set<Object, const_test_static, &Object::member_reference_const>();
 
       Data data;
       data.d = VALUE1;
@@ -627,9 +627,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_copy_construct)
     {
-      Test test;
+      Object object;
 
-      auto d1 = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int>(test);
+      auto d1 = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int>(object);
       auto d2(d1);
 
       d2(VALUE1);
@@ -641,9 +641,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_assignment)
     {
-      Test test;
+      Object object;
 
-      auto d1 = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int>(test);
+      auto d1 = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int>(object);
       etl_cpp03::delegate<void(int)> d2;
 
       d2 = d1;
@@ -657,9 +657,9 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_delegate_equal)
     {
-      Test test;
+      Object object;
 
-      auto d1 = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int>(test);
+      auto d1 = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int>(object);
       auto d2 = d1;
 
       CHECK(d1 == d2);
@@ -668,10 +668,10 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_delegate_not_equal)
     {
-      Test test;
+      Object object;
 
-      auto d1 = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int>(test);
-      auto d2 = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int_const>(test);;
+      auto d1 = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int>(object);
+      auto d2 = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int_const>(object);;
 
       CHECK(d1 != d2);
     }
@@ -776,12 +776,12 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_delegate_identification)
     {
-      Test test1;
-      Test test2;
+      Object test1;
+      Object test2;
 
       auto d1 = etl_cpp03::delegate<void(int)>::create<free_int>();
-      auto d2 = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int>(test1);
-      auto d3 = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int>(test2);
+      auto d2 = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int>(test1);
+      auto d3 = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int>(test2);
 
       etl_cpp03::delegate<void(int)> d4;
 
@@ -812,7 +812,7 @@ namespace
       CHECK(*itr != d2);
       CHECK(*itr == d3);
 
-      d4 = etl_cpp03::delegate<void(int)>::create<Test, &Test::member_int>(test2); // Same as d3
+      d4 = etl_cpp03::delegate<void(int)>::create<Object, &Object::member_int>(test2); // Same as d3
       itr = std::find(delegate_list.begin(), delegate_list.end(), d4);
       CHECK(*itr != d1);
       CHECK(*itr != d2);
diff --git a/test/test_delegate_service.cpp b/test/test_delegate_service.cpp
index 27071ac8..a9aa858e 100644
--- a/test/test_delegate_service.cpp
+++ b/test/test_delegate_service.cpp
@@ -68,12 +68,12 @@ namespace
   //*****************************************************************************
   // The test class with member functions.
   //*****************************************************************************
-  class Test
+  class Object
   {
   public:
 
-    Test()
-      : callback(Service::delegate_type::create<Test, &Test::member1>(*this))
+    Object()
+      : callback(Service::delegate_type::create<Object, &Object::member1>(*this))
     {
     }
 
@@ -93,10 +93,10 @@ namespace
     etl::delegate<void(size_t)> callback;
   };
 
-  Test test;
+  Object object;
 
   // Callback for 'member2'.
-  ETL_CONSTEXPR14 Service::delegate_type member_callback = Service::delegate_type::create<Test, test, &Test::member2>();
+  ETL_CONSTEXPR14 Service::delegate_type member_callback = Service::delegate_type::create<Object, object, &Object::member2>();
 
   // Callback for 'global'.
   ETL_CONSTEXPR14 Service::delegate_type global_callback = Service::delegate_type::create<global>();
@@ -138,7 +138,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.call<Global>();
@@ -156,7 +156,7 @@ namespace
       Service service;
 
       service.register_delegate(Global,  global_callback);
-      service.register_delegate(Member1, test.callback);
+      service.register_delegate(Member1, object.callback);
       service.register_delegate(Member2, member_callback);
 
       service.call(Global);
@@ -174,7 +174,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.call<Member1>();
@@ -192,7 +192,7 @@ namespace
       Service service;
 
       service.register_delegate(Global,  global_callback);
-      service.register_delegate(Member1, test.callback);
+      service.register_delegate(Member1, object.callback);
       service.register_delegate(Member2, member_callback);
 
       service.call(Member1);
@@ -210,7 +210,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.call<Member2>();
@@ -228,7 +228,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.call(Out_Of_Range);
@@ -246,7 +246,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.register_unhandled_delegate(unhandled_callback);
diff --git a/test/test_delegate_service_compile_time.cpp b/test/test_delegate_service_compile_time.cpp
index 320a23be..c97db964 100644
--- a/test/test_delegate_service_compile_time.cpp
+++ b/test/test_delegate_service_compile_time.cpp
@@ -67,11 +67,11 @@ namespace
   //*****************************************************************************
   // The test class with member functions.
   //*****************************************************************************
-  class Test
+  class Object
   {
   public:
 
-    Test()
+    Object()
     {
     }
 
@@ -82,10 +82,10 @@ namespace
     }
   };
 
-  Test test;
+  Object object;
 
   // Callback for 'member'.
-  ETL_CONSTEXPR14 etl::delegate<void(size_t)> member_callback = etl::delegate<void(size_t)>::create<Test, test, &Test::member>();
+  ETL_CONSTEXPR14 etl::delegate<void(size_t)> member_callback = etl::delegate<void(size_t)>::create<Object, object, &Object::member>();
 
   // Callback for 'global'.
   ETL_CONSTEXPR14 etl::delegate<void(size_t)> global_callback = etl::delegate<void(size_t)>::create<global>();
diff --git a/test/test_delegate_service_cpp03.cpp b/test/test_delegate_service_cpp03.cpp
index f8d79b85..cd2caae8 100644
--- a/test/test_delegate_service_cpp03.cpp
+++ b/test/test_delegate_service_cpp03.cpp
@@ -68,12 +68,12 @@ namespace
   //*****************************************************************************
   // The test class with member functions.
   //*****************************************************************************
-  class Test
+  class Object
   {
   public:
 
-    Test()
-      : callback(Service::delegate_type::create<Test, &Test::member1>(*this))
+    Object()
+      : callback(Service::delegate_type::create<Object, &Object::member1>(*this))
     {
     }
 
@@ -93,10 +93,10 @@ namespace
     Service::delegate_type callback;
   };
 
-  Test test;
+  Object object;
 
   // Callback for 'member2'.
-  Service::delegate_type member_callback = Service::delegate_type::create<Test, test, &Test::member2>();
+  Service::delegate_type member_callback = Service::delegate_type::create<Object, object, &Object::member2>();
 
   // Callback for 'global'.
   Service::delegate_type global_callback = Service::delegate_type::create<global>();
@@ -138,7 +138,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.call<Global>();
@@ -156,7 +156,7 @@ namespace
       Service service;
 
       service.register_delegate(Global,  global_callback);
-      service.register_delegate(Member1, test.callback);
+      service.register_delegate(Member1, object.callback);
       service.register_delegate(Member2, member_callback);
 
       service.call(Global);
@@ -174,7 +174,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.call<Member1>();
@@ -192,7 +192,7 @@ namespace
       Service service;
 
       service.register_delegate(Global,  global_callback);
-      service.register_delegate(Member1, test.callback);
+      service.register_delegate(Member1, object.callback);
       service.register_delegate(Member2, member_callback);
 
       service.call(Member1);
@@ -210,7 +210,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.call<Member2>();
@@ -228,7 +228,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.call(Out_Of_Range);
@@ -246,7 +246,7 @@ namespace
       Service service;
 
       service.register_delegate<Global>(global_callback);
-      service.register_delegate<Member1>(test.callback);
+      service.register_delegate<Member1>(object.callback);
       service.register_delegate<Member2>(member_callback);
 
       service.register_unhandled_delegate(unhandled_callback);
diff --git a/test/test_deque.cpp b/test/test_deque.cpp
index 42db7899..dcd9558b 100644
--- a/test/test_deque.cpp
+++ b/test/test_deque.cpp
@@ -29,6 +29,7 @@ SOFTWARE.
 #include "unit_test_framework.h"
 
 #include "etl/deque.h"
+#include "etl/vector.h"
 
 #include "data.h"
 
@@ -167,7 +168,6 @@ namespace
     //*************************************************************************
     TEST(test_move_constructor)
     {
-      const size_t SIZE = 10UL;
       typedef etl::deque<std::unique_ptr<uint32_t>, SIZE> Data;
 
       std::unique_ptr<uint32_t> p1(new uint32_t(1U));
@@ -196,7 +196,6 @@ namespace
     //*************************************************************************
     TEST(test_move_insert_erase)
     {
-      const size_t SIZE = 10UL;
       typedef etl::deque<std::unique_ptr<uint32_t>, SIZE> Data;
 
       std::unique_ptr<uint32_t> p1(new uint32_t(1U));
@@ -249,7 +248,6 @@ namespace
     //*************************************************************************
     TEST(test_move_assignment)
     {
-      const size_t SIZE = 10UL;
       typedef etl::deque<std::unique_ptr<uint32_t>, SIZE> Data;
 
       std::unique_ptr<uint32_t> p1(new uint32_t(1U));
@@ -294,7 +292,6 @@ namespace
     //*************************************************************************
     TEST(test_move_assignment_interface)
     {
-      const size_t SIZE = 10UL;
       typedef etl::deque<std::unique_ptr<uint32_t>, SIZE> Data;
       typedef etl::ideque<std::unique_ptr<uint32_t>> IData;
 
@@ -700,6 +697,72 @@ namespace
       CHECK(!(second < first));
     }
 
+    //*************************************************************************
+    TEST(test_reverse_iterator_difference)
+    {
+      DataNDC data(SIZE, N0);
+
+      DataNDC::reverse_iterator first  = data.rbegin() + 1;
+      DataNDC::reverse_iterator second = data.rbegin() + 4;
+
+      CHECK_EQUAL(-3, first - second);
+      CHECK_EQUAL( 3, second - first);
+    }
+
+    //*************************************************************************
+    TEST(test_const_reverse_iterator_difference)
+    {
+      DataNDC data(SIZE, N0);
+
+      DataNDC::const_reverse_iterator first  = data.crbegin() + 1;
+      DataNDC::const_reverse_iterator second = data.crbegin() + 4;
+
+      CHECK_EQUAL(-3, first - second);
+      CHECK_EQUAL( 3, second - first);
+    }
+
+    //*************************************************************************
+    TEST(test_reverse_iterator_difference_rollover)
+    {
+      DataNDC data(SIZE, N0);
+
+      data.pop_back();
+      data.pop_back();
+      data.pop_back();
+      data.pop_back();
+      data.push_front(N1);
+      data.push_front(N1);
+      data.push_front(N1);
+      data.push_front(N1);
+
+      DataNDC::reverse_iterator first  = data.rbegin() + 1;
+      DataNDC::reverse_iterator second = data.rbegin() + 4;
+
+      CHECK_EQUAL(-3,  first - second);
+      CHECK_EQUAL( 3, second - first);
+    }
+
+    //*************************************************************************
+    TEST(test_const_reverse_iterator_difference_rollover)
+    {
+      DataNDC data(SIZE, N0);
+
+      data.pop_back();
+      data.pop_back();
+      data.pop_back();
+      data.pop_back();
+      data.push_front(N1);
+      data.push_front(N1);
+      data.push_front(N1);
+      data.push_front(N1);
+
+      DataNDC::const_reverse_iterator first  = data.crbegin() + 1;
+      DataNDC::const_reverse_iterator second = data.crbegin() + 4;
+
+      CHECK_EQUAL(-3,  first - second);
+      CHECK_EQUAL( 3, second - first);
+    }
+
     //*************************************************************************
     TEST(test_reverse_iterator_comparison)
     {
@@ -2072,7 +2135,6 @@ namespace
     //*************************************************************************
     TEST(test_move)
     {
-      const size_t SIZE = 10UL;
       typedef etl::deque<std::unique_ptr<uint32_t>, SIZE> Data;
 
       Data data1;
diff --git a/test/test_expected.cpp b/test/test_expected.cpp
index 941be390..a199707a 100644
--- a/test/test_expected.cpp
+++ b/test/test_expected.cpp
@@ -32,6 +32,7 @@ SOFTWARE.
 #include "etl/type_traits.h"
 
 #include <string>
+#include <vector>
 
 namespace
 {
@@ -441,6 +442,70 @@ namespace
       CHECK_EQUAL(input1.e, output2.e);
     }
 
+    //*************************************************************************
+    TEST(test_emplace_from_initializer_list)
+    {
+      struct S
+      {
+        S()
+          : vi()
+          , a(0)
+          , b(0)
+        {
+        }
+
+        S(std::initializer_list<int> il, int a_, int b_)
+          : vi(il)
+          , a(a_)
+          , b(b_)
+        {
+        }
+
+        std::vector<int> vi;
+        int a;
+        int b;
+      };
+
+      etl::expected<S, Error> exp;
+
+      S s1({ 10, 11, 12 }, 1, 2);
+      S s2 = exp.emplace({ 10, 11, 12 }, 1, 2);
+      
+      CHECK(s1.vi == s2.vi);
+      CHECK_EQUAL(s1.a, s2.a);
+      CHECK_EQUAL(s1.b, s2.b);
+    }
+
+    //*************************************************************************
+    TEST(test_emplace_from_vargs)
+    {
+      struct S
+      {
+        S()
+          : a(0)
+          , b(0)
+        {
+        }
+
+        S(int a_, int b_)
+          : a(a_)
+          , b(b_)
+        {
+        }
+
+        int a;
+        int b;
+      };
+
+      etl::expected<S, Error> exp;
+
+      S s1(1, 2);
+      S s2 = exp.emplace(1, 2);
+
+      CHECK_EQUAL(s1.a, s2.a);
+      CHECK_EQUAL(s1.b, s2.b);
+    }
+
     //*************************************************************************
     TEST(test_move_construct_void_value)
     {
diff --git a/test/test_fixed_iterator.cpp b/test/test_fixed_iterator.cpp
index d8cde672..e440ed18 100644
--- a/test/test_fixed_iterator.cpp
+++ b/test/test_fixed_iterator.cpp
@@ -101,21 +101,21 @@ namespace
     //*************************************************************************
     TEST(test_member_dereference_operator)
     {
-      struct Test
+      struct Object
       {
         int a;
         int b;
-      } test = { 1, 2 };
+      } object = { 1, 2 };
 
-      etl::fixed_iterator<Test*> fi(&test);
+      etl::fixed_iterator<Object*> fi(&object);
 
-      CHECK_EQUAL(test.a, fi->a);
-      CHECK_EQUAL(test.b, fi->b);
+      CHECK_EQUAL(object.a, fi->a);
+      CHECK_EQUAL(object.b, fi->b);
 
       *fi = { 3, 4 };
 
-      CHECK_EQUAL(test.a, fi->a);
-      CHECK_EQUAL(test.b, fi->b);
+      CHECK_EQUAL(object.a, fi->a);
+      CHECK_EQUAL(object.b, fi->b);
     }
 
     //*************************************************************************
diff --git a/test/test_forward_list.cpp b/test/test_forward_list.cpp
index 3c23aa0b..4f46eefe 100644
--- a/test/test_forward_list.cpp
+++ b/test/test_forward_list.cpp
@@ -1000,10 +1000,13 @@ namespace
       compare_data.unique();
       data.unique();
 
-      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());
+      if ((compare_data.begin() != compare_data.end()) && (data.begin() != data.end()))
+      {
+        CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());
 
-      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
-      CHECK(are_equal);
+        are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
+        CHECK(are_equal);
+      }
     }
 
     //*************************************************************************
diff --git a/test/test_fsm.cpp b/test/test_fsm.cpp
index e092f1d2..d3481dd3 100644
--- a/test/test_fsm.cpp
+++ b/test/test_fsm.cpp
@@ -672,5 +672,13 @@ namespace
       CHECK_TRUE(motorControl.exited_state);
       CHECK_TRUE(motorControl.entered_state);
     }
+
+    //*************************************************************************
+    TEST(test_fsm_no_states_and_no_start)
+    {
+      MotorControl mc;
+
+      CHECK_THROW(mc.receive(Start()), etl::fsm_not_started);
+    }
   };
 }
diff --git a/test/test_function.cpp b/test/test_function.cpp
index cd9d1927..c64f81ca 100644
--- a/test/test_function.cpp
+++ b/test/test_function.cpp
@@ -38,7 +38,7 @@ namespace
   bool parameter_correct = false;
 
   //*****************************************************************************
-  // Test data structure.
+  // Object data structure.
   //*****************************************************************************
   struct Data
   {
@@ -126,7 +126,7 @@ namespace
   //*****************************************************************************
   // The test class with member functions.
   //*****************************************************************************
-  class Test
+  class Object
   {
   public:
 
@@ -148,7 +148,7 @@ namespace
     }
   };
 
-  Test test_static;
+  Object test_static;
 }
 
 //*****************************************************************************
@@ -298,8 +298,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void)
     {
-      Test test;
-      etl::function<Test, void> function(test, &Test::member_void);
+      Object object;
+      etl::function<Object, void> function(object, &Object::member_void);
 
       call(function);
 
@@ -309,8 +309,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_const_member_void)
     {
-      Test test;
-      const etl::function<Test, void> function(test, &Test::member_void);
+      Object object;
+      const etl::function<Object, void> function(object, &Object::member_void);
 
       call(function);
 
@@ -320,8 +320,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int)
     {
-      Test test;
-      etl::function<Test, int> function(test, &Test::member_int);
+      Object object;
+      etl::function<Object, int> function(object, &Object::member_int);
 
       call(function);
 
@@ -332,8 +332,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_const_member_int)
     {
-      Test test;
-      const etl::function<Test, int> function(test, &Test::member_int);
+      Object object;
+      const etl::function<Object, int> function(object, &Object::member_int);
 
       call(function);
 
@@ -344,8 +344,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference)
     {
-      Test test;
-      etl::function<Test, const Data&> function(test, &Test::member_reference);
+      Object object;
+      etl::function<Object, const Data&> function(object, &Object::member_reference);
 
       call(function);
 
@@ -356,8 +356,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_const_member_reference)
     {
-      Test test;
-      const etl::function<Test, const Data&> function(test, &Test::member_reference);
+      Object object;
+      const etl::function<Object, const Data&> function(object, &Object::member_reference);
 
       call(function);
 
@@ -368,8 +368,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_void_compile_time)
     {
-      Test test;
-      etl::function_mv<Test, &Test::member_void> function(test);
+      Object object;
+      etl::function_mv<Object, &Object::member_void> function(object);
 
       call(function);
 
@@ -379,8 +379,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_const_member_void_compile_time)
     {
-      Test test;
-      const etl::function_mv<Test, &Test::member_void> function(test);
+      Object object;
+      const etl::function_mv<Object, &Object::member_void> function(object);
 
       call(function);
 
@@ -390,8 +390,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_int_compile_time)
     {
-      Test test;
-      etl::function_mp<Test, int, &Test::member_int> function(test);
+      Object object;
+      etl::function_mp<Object, int, &Object::member_int> function(object);
 
       call(function);
 
@@ -402,8 +402,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_const_member_int_compile_time)
     {
-      Test test;
-      const etl::function_mp<Test, int, &Test::member_int> function(test);
+      Object object;
+      const etl::function_mp<Object, int, &Object::member_int> function(object);
 
       call(function);
 
@@ -414,8 +414,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_member_reference_compile_time)
     {
-      Test test;
-      etl::function_mp<Test, const Data&, &Test::member_reference> function(test);
+      Object object;
+      etl::function_mp<Object, const Data&, &Object::member_reference> function(object);
 
       call(function);
 
@@ -426,8 +426,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_const_member_reference_compile_time)
     {
-      Test test;
-      const etl::function_mp<Test, const Data&, &Test::member_reference> function(test);
+      Object object;
+      const etl::function_mp<Object, const Data&, &Object::member_reference> function(object);
 
       call(function);
 
@@ -440,7 +440,7 @@ namespace
     {
       function_called = false;
 
-      etl::function_imv<Test, test_static, &Test::member_void> function;
+      etl::function_imv<Object, test_static, &Object::member_void> function;
 
       call(function);
 
@@ -452,7 +452,7 @@ namespace
     {
       function_called = false;
 
-      const etl::function_imv<Test, test_static, &Test::member_void> function;
+      const etl::function_imv<Object, test_static, &Object::member_void> function;
 
       call(function);
 
@@ -464,7 +464,7 @@ namespace
     {
       function_called = false;
 
-      etl::function_imp<Test, int, test_static, &Test::member_int> function;
+      etl::function_imp<Object, int, test_static, &Object::member_int> function;
 
       call(function);
 
@@ -476,7 +476,7 @@ namespace
     {
       function_called = false;
 
-      const etl::function_imp<Test, int, test_static, &Test::member_int> function;
+      const etl::function_imp<Object, int, test_static, &Object::member_int> function;
 
       call(function);
 
@@ -488,7 +488,7 @@ namespace
     {
       function_called = false;
 
-      etl::function_imp<Test, const Data&, test_static, &Test::member_reference> function;
+      etl::function_imp<Object, const Data&, test_static, &Object::member_reference> function;
 
       call(function);
 
@@ -500,7 +500,7 @@ namespace
     {
       function_called = false;
 
-      const etl::function_imp<Test, const Data&, test_static, &Test::member_reference> function;
+      const etl::function_imp<Object, const Data&, test_static, &Object::member_reference> function;
 
       call(function);
 
diff --git a/test/test_functional.cpp b/test/test_functional.cpp
index 1b9eea52..9970cf25 100644
--- a/test/test_functional.cpp
+++ b/test/test_functional.cpp
@@ -50,6 +50,41 @@ namespace
     }
   };
 
+  struct MemFnTest
+  {
+    std::string Function1()
+    {
+      return std::string("Function1");
+    }
+
+    std::string Function2(const std::string& arg1)
+    {
+      return std::string("Function2: ") + arg1;
+    }
+
+    std::string Function3(const std::string& arg1, const std::string& arg2)
+    {
+      return std::string("Function3: ") + arg1 + arg2;
+    }
+
+    std::string Function1_Const() const
+    {
+      return std::string("Function1_Const");
+    }
+
+    std::string Function2_Const(const std::string& arg1) const
+    {
+      return std::string("Function2_Const: ") + arg1;
+    }
+
+    std::string Function3_Const(const std::string& arg1, const std::string& arg2) const
+    {
+      return std::string("Function3_Const: ") + arg1 + arg2;
+    }
+
+    mutable std::string result;
+  };
+
   SUITE(test_functional)
   {
     //*************************************************************************
@@ -278,5 +313,71 @@ namespace
       CHECK_EQUAL(uint8_t(~0xAAU), f(0xAAU));
       CHECK_EQUAL(uint8_t(~0xFFU), f(0xFFU));
     }
+
+    //*************************************************************************
+    TEST(test_mem_fn)
+    {
+      MemFnTest mft;
+      std::string result;
+
+      auto f1 = etl::mem_fn(&MemFnTest::Function1);
+      result.clear();
+      result = f1(mft);
+      CHECK_EQUAL("Function1", result);
+
+      auto f2 = etl::mem_fn(&MemFnTest::Function2);
+      result.clear();
+      result = f2(mft, "Arg1");
+      CHECK_EQUAL("Function2: Arg1", result);
+
+      auto f3 = etl::mem_fn(&MemFnTest::Function3);
+      result.clear();
+      result = f3(mft, "Arg1", " : Arg2");
+      CHECK_EQUAL("Function3: Arg1 : Arg2", result);
+    }
+
+    //*************************************************************************
+    TEST(test_const_mem_fn)
+    {
+      const MemFnTest mft;
+      std::string result;
+
+      auto f1 = etl::mem_fn(&MemFnTest::Function1_Const);
+      result.clear();
+      result = f1(mft);
+      CHECK_EQUAL("Function1_Const", result);
+
+      auto f2 = etl::mem_fn(&MemFnTest::Function2_Const);
+      result.clear();
+      result = f2(mft, "Arg1");
+      CHECK_EQUAL("Function2_Const: Arg1", result);
+
+      auto f3 = etl::mem_fn(&MemFnTest::Function3_Const);
+      result.clear();
+      result = f3(mft, "Arg1", " : Arg2");
+      CHECK_EQUAL("Function3_Const: Arg1 : Arg2", result);
+    }
+
+    //*************************************************************************
+    TEST(test_constexpr_mem_fn)
+    {
+      const MemFnTest mft;
+      std::string result;
+
+      constexpr auto f1 = etl::mem_fn(&MemFnTest::Function1_Const);
+      result.clear();
+      result = f1(mft);
+      CHECK_EQUAL("Function1_Const", result);
+
+      constexpr auto f2 = etl::mem_fn(&MemFnTest::Function2_Const);
+      result.clear();
+      result = f2(mft, "Arg1");
+      CHECK_EQUAL("Function2_Const: Arg1", result);
+
+      constexpr auto f3 = etl::mem_fn(&MemFnTest::Function3_Const);
+      result.clear();
+      result = f3(mft, "Arg1", " : Arg2");
+      CHECK_EQUAL("Function3_Const: Arg1 : Arg2", result);
+    }
   };
 }
diff --git a/test/test_hfsm.cpp b/test/test_hfsm.cpp
index 584c3f48..4ea762ab 100644
--- a/test/test_hfsm.cpp
+++ b/test/test_hfsm.cpp
@@ -978,5 +978,13 @@ namespace
       bool exitsCorrect = std::equal(motorControl.stateExitHistory.begin(), motorControl.stateExitHistory.end(), expectedExits.begin());
       CHECK(exitsCorrect);
     }
+
+    //*************************************************************************
+    TEST(test_fsm_no_states_and_no_start)
+    {
+      MotorControl mc;
+
+      CHECK_THROW(mc.receive(Start()), etl::fsm_not_started);
+    }
   };
 }
diff --git a/test/test_indirect_vector.cpp b/test/test_indirect_vector.cpp
index 8cfff65b..bcc3b08d 100644
--- a/test/test_indirect_vector.cpp
+++ b/test/test_indirect_vector.cpp
@@ -1427,9 +1427,9 @@ namespace
     {
       struct functor
       {
-        void operator()(const NDC& ndc)
+        void operator()(const NDC& object)
         {
-          result += ndc.value;
+          result += object.value;
         }
 
         std::string result;
@@ -1458,9 +1458,9 @@ namespace
     {
       struct functor
       {
-        bool operator()(const NDC& ndc)
+        bool operator()(const NDC& object)
         {
-          return ndc.value == "4";
+          return object.value == "4";
         }
 
         std::string result;
diff --git a/test/test_indirect_vector_external_buffer.cpp b/test/test_indirect_vector_external_buffer.cpp
index 138029a8..7911eabd 100644
--- a/test/test_indirect_vector_external_buffer.cpp
+++ b/test/test_indirect_vector_external_buffer.cpp
@@ -1560,9 +1560,9 @@ namespace
     {
       struct functor
       {
-        void operator()(const NDC& ndc)
+        void operator()(const NDC& object)
         {
-          result += ndc.value;
+          result += object.value;
         }
 
         std::string result;
@@ -1594,9 +1594,9 @@ namespace
     {
       struct functor
       {
-        bool operator()(const NDC& ndc)
+        bool operator()(const NDC& object)
         {
-          return ndc.value == "4";
+          return object.value == "4";
         }
 
         std::string result;
diff --git a/test/test_intrusive_forward_list.cpp b/test/test_intrusive_forward_list.cpp
index 0445639d..20c8d830 100644
--- a/test/test_intrusive_forward_list.cpp
+++ b/test/test_intrusive_forward_list.cpp
@@ -140,8 +140,6 @@ namespace
     InitialDataNDC merge_data3;
     InitialDataNDC merge_data4;
 
-    bool are_equal;
-
     //*************************************************************************
     struct SetupFixture
     {
@@ -204,7 +202,7 @@ namespace
     {
       DataNDC0 data0(sorted_data.begin(), sorted_data.end());
 
-      are_equal = std::equal(data0.begin(), data0.end(), sorted_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), sorted_data.begin());
 
       CHECK(are_equal);
     }
@@ -229,7 +227,7 @@ namespace
     {
       DataNDC0 data0(sorted_data.begin(), sorted_data.end());
 
-      are_equal = std::equal(data0.cbegin(), data0.cend(), sorted_data.begin());
+      bool are_equal = std::equal(data0.cbegin(), data0.cend(), sorted_data.begin());
 
       CHECK(are_equal);
     }
@@ -274,13 +272,13 @@ namespace
     {
       DataNDC0 data0;
 
-      static InitialDataNDC sorted_data = { ItemNDCNode("0"), ItemNDCNode("1"), ItemNDCNode("2"), ItemNDCNode("3"), ItemNDCNode("4"), ItemNDCNode("5"), ItemNDCNode("6"), ItemNDCNode("7"), ItemNDCNode("8"), ItemNDCNode("9") };
+      static InitialDataNDC assign_data = { ItemNDCNode("0"), ItemNDCNode("1"), ItemNDCNode("2"), ItemNDCNode("3"), ItemNDCNode("4"), ItemNDCNode("5"), ItemNDCNode("6"), ItemNDCNode("7"), ItemNDCNode("8"), ItemNDCNode("9") };
 
       // Do it twice. We should only get one copy.
-      data0.assign(sorted_data.begin(), sorted_data.end());
-      data0.assign(sorted_data.begin(), sorted_data.end());
+      data0.assign(assign_data.begin(), assign_data.end());
+      data0.assign(assign_data.begin(), assign_data.end());
 
-      bool are_equal = std::equal(data0.begin(), data0.end(), sorted_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), assign_data.begin());
 
       CHECK(are_equal);
     }
@@ -294,7 +292,7 @@ namespace
       data0.assign(sorted_data.begin(), sorted_data.end());
       data1.assign(sorted_data.begin(), sorted_data.end());
 
-      are_equal = std::equal(data0.begin(), data0.end(), sorted_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), sorted_data.begin());
       CHECK(are_equal);
 
       are_equal = std::equal(data1.begin(), data1.end(), sorted_data.begin());
@@ -341,7 +339,7 @@ namespace
         data0.push_front(node6);
         data0.push_front(node7);
 
-        are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+        bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
         CHECK(are_equal);
         CHECK_EQUAL(6U, data0.size());
         CHECK_EQUAL(6, std::distance(data0.begin(), data0.end()));
@@ -381,7 +379,7 @@ namespace
       data0.insert_after(i_data, INSERT_VALUE1);
       compare_data.insert_after(i_compare_data, INSERT_VALUE1);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
       CHECK(are_equal);
       CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data0.size());
       CHECK_EQUAL(std::distance(compare_data.begin(), compare_data.end()), std::distance(data0.begin(), data0.end()));
@@ -426,7 +424,7 @@ namespace
 
       data0.insert_after(data0.before_begin(), test2.begin(), test2.end());
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare.begin());
       CHECK(are_equal);
 
       are_equal = std::equal(data1.begin(), data1.end(), test1.begin());
@@ -485,7 +483,7 @@ namespace
         CHECK_NO_THROW(data0.push_front(node5));
         CHECK_NO_THROW(data0.push_front(node6));
 
-        are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+        bool are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
         CHECK(are_equal);
         CHECK_EQUAL(6U, data0.size());
         CHECK_EQUAL(6, std::distance(data0.begin(), data0.end()));
@@ -573,7 +571,7 @@ namespace
       i_compare_data = compare_data.erase_after(i_compare_data);
       i_data         = data0.erase_after(i_data);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
 
       CHECK(are_equal);
       CHECK(*i_compare_data == *i_data);
@@ -617,6 +615,90 @@ namespace
       CHECK(are_equal);
     }
 
+    //*************************************************************************
+    TEST_FIXTURE(SetupFixture, test_erase_single_by_node_reference)
+    {
+      bool are_equal;
+
+      std::vector<ItemNDCNode> compare_data(sorted_data.begin(), sorted_data.end());
+      DataNDC0 data0(sorted_data.begin(), sorted_data.end());
+      DataNDC1 data1(sorted_data.begin(), sorted_data.end());
+
+      // Move to the third value and erase.
+      std::vector<ItemNDCNode>::iterator i_compare_data = compare_data.begin();
+      std::advance(i_compare_data, 3);
+
+      DataNDC0::iterator i_data = data0.begin();
+      std::advance(i_data, 3);
+
+      ItemNDCNode& node1 = *i_data;
+      ItemNDCNode* p_next1 = static_cast<ItemNDCNode*>(node1.FirstLink::get_next());
+      ItemNDCNode* p_node1 = data0.erase(node1);
+      i_compare_data = compare_data.erase(i_compare_data);
+
+      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+
+      CHECK(are_equal);
+      CHECK_EQUAL(p_next1, p_node1);
+      CHECK_EQUAL(compare_data.size(), data0.size());
+      CHECK_EQUAL(compare_data.size(), size_t(std::distance(data0.begin(), data0.end())));
+
+      // Move to the first value and erase.
+      i_compare_data = compare_data.begin();
+      i_compare_data = compare_data.erase(i_compare_data);
+
+      i_data = data0.begin();
+
+      ItemNDCNode& node2 = *i_data;
+      ItemNDCNode* p_next2 = static_cast<ItemNDCNode*>(node2.FirstLink::get_next());
+      ItemNDCNode* p_node2 = data0.erase(node2);
+
+      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+
+      CHECK(are_equal);
+      CHECK_EQUAL(p_next2, p_node2);
+      CHECK_EQUAL(compare_data.size(), data0.size());
+      CHECK_EQUAL(compare_data.size(), size_t(std::distance(data0.begin(), data0.end())));
+
+      // Move to the last value and erase.
+      i_compare_data = compare_data.begin();
+      std::advance(i_compare_data, compare_data.size() - 1);
+
+      i_data = data0.begin();
+      std::advance(i_data, data0.size() - 1);
+
+      ItemNDCNode& node3 = *i_data;
+      ItemNDCNode* p_next3 = static_cast<ItemNDCNode*>(node3.FirstLink::get_next());
+      ItemNDCNode* p_node3 = data0.erase(node3);
+      i_compare_data = compare_data.erase(i_compare_data);
+
+      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+
+      CHECK(are_equal);
+      CHECK_NOT_EQUAL(p_next3, p_node3);
+      CHECK(ETL_NULLPTR == p_node3);
+      CHECK_EQUAL(compare_data.size(), data0.size());
+      CHECK_EQUAL(compare_data.size(), size_t(std::distance(data0.begin(), data0.end())));
+
+      // Try removing a node that isn't in the list.
+      auto node_not_in_list = ItemNDCNode("9");
+
+      ItemNDCNode* p_node4 = data0.erase(node_not_in_list);
+      CHECK(p_node4 == ETL_NULLPTR);
+
+      // Try removing the only node in the list.
+      while (data0.size() > 1)
+      {
+        data0.pop_front();
+      }
+
+      ItemNDCNode* p_node5 = &data0.front();
+
+      ItemNDCNode* p_next5 = static_cast<ItemNDCNode*>(p_node5->FirstLink::get_next());
+      p_next5 = data0.erase(*p_node5);
+      CHECK(ETL_NULLPTR == p_next5);
+    }
+
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_erase_after_range)
     {
@@ -675,7 +757,7 @@ namespace
 
       CHECK_EQUAL(*i_compare_result, *i_result);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
       CHECK(are_equal);
       CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data0.size());
       CHECK_EQUAL(std::distance(compare_data.begin(), compare_data.end()), std::distance(data0.begin(), data0.end()));
@@ -705,7 +787,7 @@ namespace
 
       CHECK(i_result == data0.end());
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
       CHECK(are_equal);
       CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data0.size());
       CHECK_EQUAL(std::distance(compare_data.begin(), compare_data.end()), std::distance(data0.begin(), data0.end()));
@@ -743,7 +825,7 @@ namespace
       data0.unique(EqualItemNDCNode());
 
       // data0 should have changed.
-      are_equal = std::equal(data0.begin(), data0.end(), unique_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), unique_data.begin());
       CHECK(are_equal);
       CHECK_EQUAL(unique_data.size(), data0.size());
       CHECK_EQUAL(unique_data.size(), size_t(std::distance(data0.begin(), data0.end())));
@@ -765,7 +847,7 @@ namespace
       compare_data.remove(ItemNDCNode("7"));
       data0.remove(ItemNDCNode("7"));
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
 
       CHECK(are_equal);
       CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data0.size());
@@ -787,7 +869,7 @@ namespace
       compare_data.remove_if(std::bind(std::equal_to<ItemNDCNode>(), std::placeholders::_1, ItemNDCNode("7")));
       data0.remove_if(std::bind(std::equal_to<ItemNDCNode>(), std::placeholders::_1, ItemNDCNode("7")));
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
 
       CHECK(are_equal);
       CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data0.size());
@@ -827,7 +909,7 @@ namespace
 
       data0.sort(); // Just sort one of them.
 
-      are_equal = std::equal(data0.begin(), data0.end(), sorted_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), sorted_data.begin());
       CHECK(are_equal);
 
       are_equal = std::equal(data1.begin(), data1.end(), unsorted_data.begin());
@@ -863,7 +945,7 @@ namespace
 
       data0.sort(CompareItemNDCNode()); // Just sort one of them.
 
-      are_equal = std::equal(data0.begin(), data0.end(), sorted_data.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), sorted_data.begin());
       CHECK(are_equal);
 
       are_equal = std::equal(data1.begin(), data1.end(), unsorted_data.begin());
@@ -888,7 +970,7 @@ namespace
       data0.splice_after(idata_destination, data1);
       compare0.splice_after(icompare_destination, compare1);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
       CHECK(are_equal);
 
       CHECK_EQUAL(size_t(std::distance(compare0.begin(), compare0.end())), data0.size());
@@ -907,7 +989,7 @@ namespace
 
       data0.splice_after(idata_destination, data0);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
       CHECK(are_equal);
 
       CHECK_EQUAL(size_t(std::distance(compare0.begin(), compare0.end())), data0.size());
@@ -943,7 +1025,7 @@ namespace
       data0.splice_after(idata_destination, data1, idata_begin, idata_end);
       compare0.splice_after(icompare_destination, compare1, icompare_begin, icompare_end);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
       CHECK(are_equal);
 
       CHECK_EQUAL(size_t(std::distance(compare0.begin(), compare0.end())), data0.size());
@@ -978,7 +1060,7 @@ namespace
       data0.splice_after(idata_destination, data0, idata_begin, idata_end);
       compare0.splice_after(icompare_destination, compare0, icompare_begin, icompare_end);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
       CHECK(are_equal);
 
       CHECK_EQUAL(size_t(std::distance(compare0.begin(), compare0.end())), data0.size());
@@ -996,7 +1078,7 @@ namespace
       data0.merge(data1);
       compare0.merge(compare1);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
       CHECK(are_equal);
 
       CHECK_EQUAL(size_t(std::distance(compare0.begin(), compare0.end())), data0.size());
@@ -1015,7 +1097,7 @@ namespace
       data0.merge(data2);
       compare0.merge(compare2);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
       CHECK(are_equal);
 
       CHECK_EQUAL(size_t(std::distance(compare0.begin(), compare0.end())), data0.size());
@@ -1034,7 +1116,7 @@ namespace
       data0.merge(data3);
       compare0.merge(compare3);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
       CHECK(are_equal);
 
       CHECK_EQUAL(size_t(std::distance(compare0.begin(), compare0.end())), data0.size());
@@ -1053,7 +1135,7 @@ namespace
       data0.merge(data4);
       compare0.merge(compare4);
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
       CHECK(are_equal);
 
       CHECK_EQUAL(size_t(std::distance(compare0.begin(), compare0.end())), data0.size());
@@ -1078,7 +1160,7 @@ namespace
       data0.merge(data1,       std::greater<ItemNDCNode>());
       compare0.merge(compare1, std::greater<ItemNDCNode>());
 
-      are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
+      bool are_equal = std::equal(data0.begin(), data0.end(), compare0.begin());
       CHECK(are_equal);
 
       CHECK_EQUAL(size_t(std::distance(compare0.begin(), compare0.end())), data0.size());
diff --git a/test/test_intrusive_list.cpp b/test/test_intrusive_list.cpp
index 0f3e0479..33aa4467 100644
--- a/test/test_intrusive_list.cpp
+++ b/test/test_intrusive_list.cpp
@@ -734,7 +734,7 @@ namespace
       are_equal = *i_data == *i_compare_data;
       CHECK(are_equal);
 
-      // Move to the last value and erase.
+      // Move to the first value and erase.
       i_compare_data = compare_data.begin();
       i_compare_data = compare_data.erase(i_compare_data);
 
@@ -756,6 +756,90 @@ namespace
       CHECK(are_equal);
     }
 
+    //*************************************************************************
+    TEST_FIXTURE(SetupFixture, test_erase_single_by_node_reference)
+    {
+      bool are_equal;
+
+      std::vector<ItemNDCNode> compare_data(sorted_data.begin(), sorted_data.end());
+      DataNDC0 data0(sorted_data.begin(), sorted_data.end());
+      DataNDC1 data1(sorted_data.begin(), sorted_data.end());
+
+      // Move to the third value and erase.
+      std::vector<ItemNDCNode>::iterator i_compare_data = compare_data.begin();
+      std::advance(i_compare_data, 3);
+
+      DataNDC0::iterator i_data = data0.begin();
+      std::advance(i_data, 3);
+
+      ItemNDCNode& node1   = *i_data;
+      ItemNDCNode* p_next1 = static_cast<ItemNDCNode*>(node1.FirstLink::get_next());
+      ItemNDCNode* p_node1 = data0.erase(node1);
+      i_compare_data = compare_data.erase(i_compare_data);
+
+      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+
+      CHECK(are_equal);
+      CHECK_EQUAL(p_next1, p_node1);
+      CHECK_EQUAL(compare_data.size(), data0.size());
+      CHECK_EQUAL(compare_data.size(), size_t(std::distance(data0.begin(), data0.end())));
+
+      // Move to the first value and erase.
+      i_compare_data = compare_data.begin();
+      i_compare_data = compare_data.erase(i_compare_data);
+
+      i_data = data0.begin();
+
+      ItemNDCNode& node2   = *i_data;
+      ItemNDCNode* p_next2 = static_cast<ItemNDCNode*>(node2.FirstLink::get_next());
+      ItemNDCNode* p_node2 = data0.erase(node2);
+
+      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+
+      CHECK(are_equal);
+      CHECK_EQUAL(p_next2, p_node2);
+      CHECK_EQUAL(compare_data.size(), data0.size());
+      CHECK_EQUAL(compare_data.size(), size_t(std::distance(data0.begin(), data0.end())));
+
+      // Move to the last value and erase.
+      i_compare_data = compare_data.begin();
+      std::advance(i_compare_data, compare_data.size() - 1);
+
+      i_data = data0.begin();
+      std::advance(i_data, data0.size() - 1);
+
+      ItemNDCNode& node3 = *i_data;
+      ItemNDCNode* p_next3 = static_cast<ItemNDCNode*>(node3.FirstLink::get_next());
+      ItemNDCNode* p_node3 = data0.erase(node3);
+      i_compare_data = compare_data.erase(i_compare_data);
+
+      are_equal = std::equal(data0.begin(), data0.end(), compare_data.begin());
+
+      CHECK(are_equal);
+      CHECK_NOT_EQUAL(p_next3, p_node3);
+      CHECK(ETL_NULLPTR == p_node3);
+      CHECK_EQUAL(compare_data.size(), data0.size());
+      CHECK_EQUAL(compare_data.size(), size_t(std::distance(data0.begin(), data0.end())));
+
+      // Try removing a node that isn't in the list.
+      auto node_not_in_list = ItemNDCNode("9");
+
+      ItemNDCNode* p_node4 = data0.erase(node_not_in_list);
+      CHECK(p_node4 == ETL_NULLPTR);
+
+      // Try removing the only node in the list.
+      while (data0.size() > 1)
+      {
+        data0.pop_back();
+      }
+
+      ItemNDCNode* p_node5 = &data0.front();
+
+      ItemNDCNode* p_next5 = static_cast<ItemNDCNode*>(p_node5->FirstLink::get_next());
+      p_next5 = data0.erase(*p_node5);
+      CHECK(ETL_NULLPTR == p_next5);
+    }
+
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_erase_range)
     {
diff --git a/test/test_iterator.cpp b/test/test_iterator.cpp
index fbbb0f4a..c777574d 100644
--- a/test/test_iterator.cpp
+++ b/test/test_iterator.cpp
@@ -30,6 +30,7 @@ SOFTWARE.
 
 #include <string>
 #include <list>
+#include <queue>
 #include <algorithm>
 
 #include "etl/iterator.h"
@@ -561,5 +562,23 @@ namespace
       CHECK_EQUAL(expected.size(), output.size());
       CHECK(std::equal(output.begin(), output.end(), expected.begin()));
     }
+
+    //*************************************************************************
+    //TEST(test_push_insert_iterator)
+    //{
+    //  std::list<int> input = { 0, 1, 2, 3,  4,  5,  6,  7,  8,  9 };
+    //  std::list<int> expected = { 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 };
+    //  std::queue<int> output;
+
+    //  auto squared = [](int value)
+    //  {
+    //    return value * value;
+    //  };
+
+    //  std::transform(input.begin(), input.cend(), etl::push_inserter(output), squared);
+
+    //  CHECK_EQUAL(expected.size(), output.size());
+    //  CHECK(std::equal(output.begin(), output.end(), expected.begin()));
+    //}
   };
 }
diff --git a/test/test_map.cpp b/test/test_map.cpp
index ee6f0eae..bd8817ce 100644
--- a/test/test_map.cpp
+++ b/test/test_map.cpp
@@ -86,6 +86,7 @@ namespace
   SUITE(test_map)
   {
     //*************************************************************************
+#include "etl/private/diagnostic_null_dereference_push.h"
     template <typename T1, typename T2>
     bool Check_Equal(T1 begin1, T1 end1, T2 begin2)
     {
@@ -102,6 +103,7 @@ namespace
 
       return true;
     }
+#include "etl/private/diagnostic_pop.h"
 
     //*************************************************************************
     struct SetupFixture
diff --git a/test/test_memory.cpp b/test/test_memory.cpp
index 69beb317..c12ad5ba 100644
--- a/test/test_memory.cpp
+++ b/test/test_memory.cpp
@@ -640,25 +640,25 @@ namespace
     //*************************************************************************
     TEST(test_create_copy)
     {
-      struct Test : etl::create_copy<Test>
+      struct Object : etl::create_copy<Object>
       {
         std::string text;
       };
 
-      char buffer[sizeof(Test)];
+      char buffer[sizeof(Object)];
 
-      Test test1;
-      test1.text = "12345678";
-      test1.create_copy_at(buffer);
-      test1.text = "87654321";
+      Object object1;
+      object1.text = "12345678";
+      object1.create_copy_at(buffer);
+      object1.text = "87654321";
 
-      Test& test2 = *reinterpret_cast<Test*>(buffer);
+      Object& object2 = *reinterpret_cast<Object*>(buffer);
 
-      CHECK_EQUAL(std::string("87654321"), test1.text);
-      CHECK_EQUAL(std::string("12345678"), test2.text);
+      CHECK_EQUAL(std::string("87654321"), object1.text);
+      CHECK_EQUAL(std::string("12345678"), object2.text);
 
       int count = 0;
-      test1.create_copy_at(buffer, count);
+      object1.create_copy_at(buffer, count);
 
       CHECK_EQUAL(1, count);
     }
@@ -666,23 +666,23 @@ namespace
     //*************************************************************************
     TEST(test_create_make_copy)
     {
-      struct Test : etl::create_copy<Test>
+      struct Object : etl::create_copy<Object>
       {
         std::string text;
       };
 
-      char buffer[sizeof(Test)];
+      char buffer[sizeof(Object)];
 
-      Test test1;
-      test1.text = "12345678";
-      Test& test2 = test1.make_copy_at(buffer);
-      test1.text = "87654321";
+      Object object1;
+      object1.text = "12345678";
+      Object& object2 = object1.make_copy_at(buffer);
+      object1.text = "87654321";
 
-      CHECK_EQUAL(std::string("87654321"), test1.text);
-      CHECK_EQUAL(std::string("12345678"), test2.text);
+      CHECK_EQUAL(std::string("87654321"), object1.text);
+      CHECK_EQUAL(std::string("12345678"), object2.text);
 
       int count = 0;
-      test1.make_copy_at(buffer, count);
+      object1.make_copy_at(buffer, count);
 
       CHECK_EQUAL(1, count);
     }
@@ -924,6 +924,17 @@ namespace
       CHECK(!bool(up));
     }
 
+    //*************************************************************************
+    TEST(test_unique_ptr_nullptr_from_nullptr_assignment)
+    {
+      etl::unique_ptr<int> up;
+
+      up = nullptr;
+
+      CHECK(up.get() == nullptr);
+      CHECK(!bool(up));
+    }
+
     //*************************************************************************
     TEST(test_unique_ptr_move_assignment)
     {
diff --git a/test/test_message.cpp b/test/test_message.cpp
new file mode 100644
index 00000000..6a41f8fd
--- /dev/null
+++ b/test/test_message.cpp
@@ -0,0 +1,132 @@
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2024 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#include "unit_test_framework.h"
+
+#include "etl/message.h"
+
+SUITE(test_message)
+{
+  //*************************************************************************
+  TEST(test_message_traits)
+  {
+    // imessage
+    //   ^
+    // MessageBase 
+    //   ^
+    // etl::message<I, MessageBase>
+    //   ^
+    // Message
+
+    //             | is_imessage | is_message | is_message_type | is_message_base | is_user_message_base
+    // imessage    |     T       |     T      |     F           |     T           |     F
+    // MessageBase |     F       |     T      |     F           |     T           |     T
+    // Message     |     F       |     T      |     T           |     F           |     F
+    // int         |     F       |     F      |     F           |     F           |     F
+
+    struct MessageBase : public etl::imessage {};
+    struct Message : public etl::message<1, MessageBase> {};
+
+#if ETL_USING_CPP17
+    // Is an imessage?
+    CHECK_TRUE(etl::is_imessage_v<etl::imessage>);
+    CHECK_FALSE(etl::is_imessage_v<MessageBase>);
+    CHECK_FALSE(etl::is_imessage_v<Message>);
+    CHECK_FALSE(etl::is_imessage_v<int>);
+
+    // Is an imessage, or derived from imessage?
+    CHECK_TRUE(etl::is_message_v<etl::imessage>);
+    CHECK_TRUE(etl::is_message_v<MessageBase>);
+    CHECK_TRUE(etl::is_message_v<Message>);
+    CHECK_FALSE(etl::is_message_v<int>);
+
+    // Is a concrete message?
+    CHECK_FALSE(etl::is_message_type_v<etl::imessage>);
+    CHECK_FALSE(etl::is_message_type_v<MessageBase>);
+    CHECK_TRUE(etl::is_message_type_v<Message>);
+    CHECK_FALSE(etl::is_message_type_v<int>);
+
+    // Is a message base?
+    CHECK_TRUE(etl::is_message_base_v<etl::imessage>);
+    CHECK_TRUE(etl::is_message_base_v<MessageBase>);
+    CHECK_FALSE(etl::is_message_base_v<Message>);
+    CHECK_FALSE(etl::is_message_base_v<int>);
+
+    // Is a user message base?
+    CHECK_FALSE(etl::is_user_message_base_v<etl::imessage>);
+    CHECK_TRUE(etl::is_user_message_base_v<MessageBase>);
+    CHECK_FALSE(etl::is_user_message_base_v<Message>);
+    CHECK_FALSE(etl::is_user_message_base_v<int>);
+#else
+    // Is an imessage?
+    CHECK_TRUE(etl::is_imessage<etl::imessage>::value);
+    CHECK_FALSE(etl::is_imessage<MessageBase>::value);
+    CHECK_FALSE(etl::is_imessage<Message>::value);
+    CHECK_FALSE(etl::is_imessage<int>::value);
+
+    // Is an imessage, or derived from imessage?
+    CHECK_TRUE(etl::is_message<etl::imessage>::value);
+    CHECK_TRUE(etl::is_message<MessageBase>::value);
+    CHECK_TRUE(etl::is_message<Message>::value);
+    CHECK_FALSE(etl::is_message<int>::value);
+
+    // Is a concrete message?
+    CHECK_FALSE(etl::is_message_type<etl::imessage>::value);
+    CHECK_FALSE(etl::is_message_type<MessageBase>::value);
+    CHECK_TRUE(etl::is_message_type<Message>::value);
+    CHECK_FALSE(etl::is_message_type<int>::value);
+
+    // Is a message base?
+    CHECK_TRUE(etl::is_message_base<etl::imessage>::value);
+    CHECK_TRUE(etl::is_message_base<MessageBase>::value);
+    CHECK_FALSE(etl::is_message_base<Message>::value);
+    CHECK_FALSE(etl::is_message_base<int>::value);
+
+    // Is a user message base?
+    CHECK_FALSE(etl::is_user_message_base<etl::imessage>::value);
+    CHECK_TRUE(etl::is_user_message_base<MessageBase>::value);
+    CHECK_FALSE(etl::is_user_message_base<Message>::value);
+    CHECK_FALSE(etl::is_user_message_base<int>::value);
+#endif
+  }
+
+  //*************************************************************************
+  TEST(test_message_base_type)
+  {
+    struct Message1 : public etl::message<1> {};
+    
+    struct MessageBase : public etl::imessage {};
+    struct Message2 : public etl::message<2, MessageBase> {};
+
+    CHECK_TRUE((std::is_same_v<etl::imessage, Message1::base_type>));
+    CHECK_TRUE((std::is_same_v<MessageBase,   Message2::base_type>));
+
+    CHECK_FALSE((std::is_same_v<MessageBase,   Message1::base_type>));
+    CHECK_FALSE((std::is_same_v<etl::imessage, Message2::base_type>));
+  }
+};
diff --git a/test/test_message_broker.cpp b/test/test_message_broker.cpp
index 3a414d8e..fda9ae16 100644
--- a/test/test_message_broker.cpp
+++ b/test/test_message_broker.cpp
@@ -232,7 +232,7 @@ namespace
   SUITE(test_message_broker)
   {
     //*************************************************************************
-    TEST(message_check_broker_id)
+    TEST(test_message_check_broker_id)
     {
       Broker broker1;
       Broker broker2(2);
@@ -245,7 +245,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(message_broker_subscribe_then_unsubscribe)
+    TEST(test_message_broker_subscribe_then_unsubscribe)
     {
       Router router1(1);
       Router router2(2);
@@ -255,33 +255,27 @@ namespace
       Subscription subscription3{ router2, { Message1::ID, Message3::ID } };
 
       Broker broker; 
-      CHECK(broker.empty());
-      CHECK(broker.accepts(MESSAGE1));
-      CHECK(broker.accepts(MESSAGE2));
-      CHECK(broker.accepts(MESSAGE3));
-      CHECK(broker.accepts(MESSAGE4));
-      CHECK(broker.accepts(MESSAGE5));
-      CHECK(broker.accepts(MESSAGE6));
-
+      CHECK_TRUE(broker.empty());
+      
       broker.subscribe(subscription1);
-      CHECK(!broker.empty());
+      CHECK_FALSE(broker.empty());
 
       broker.subscribe(subscription3);
-      CHECK(!broker.empty());
+      CHECK_FALSE(broker.empty());
 
       broker.unsubscribe(router1);
-      CHECK(!broker.empty());
+      CHECK_FALSE(broker.empty());
 
       broker.unsubscribe(router2);
-      CHECK(broker.empty());
+      CHECK_TRUE(broker.empty());
 
       // There is no router3 subscription in 'broker'.
       broker.unsubscribe(router3);
-      CHECK(broker.empty());
+      CHECK_TRUE(broker.empty());
     }
 
     //*************************************************************************
-    TEST(message_broker_subscribe_then_clear)
+    TEST(test_message_broker_subscribe_then_clear)
     {
       Router router1(1);
       Router router2(2);
@@ -337,7 +331,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(message_broker_send_messages_to_broker_with_no_subscribers)
+    TEST(test_message_broker_send_messages_to_broker_with_no_subscribers)
     {
       Broker broker;
       Router router1(1);
@@ -382,7 +376,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(message_broker_send_messages_to_subscribers)
+    TEST(test_message_broker_send_messages_to_subscribers)
     {
       Broker broker;
       Router router1(1);
@@ -439,7 +433,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(message_broker_send_messages_to_specific_subscribers)
+    TEST(test_message_broker_send_messages_to_specific_subscribers)
     {
       Broker broker;
       Router router1(1);
@@ -460,7 +454,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(message_broker_send_messages_to_subscribers_after_unsubscribe)
+    TEST(test_message_broker_send_messages_to_subscribers_after_unsubscribe)
     {
       Broker broker;
       Router router1(1);
@@ -516,5 +510,53 @@ namespace
       CHECK_EQUAL(0, router2.message_unknown_count);
       CHECK_EQUAL(1, router3.message_unknown_count);
     }
+
+    //*************************************************************************
+    TEST(test_message_broker_accepts)
+    {
+      Router router1(1);
+      Router router2(2);
+      Router router3(3);
+
+      Subscription subscription1{ router1, { Message1::ID, Message3::ID } };
+      Subscription subscription2{ router2, { Message1::ID, Message2::ID, Message3::ID, Message4::ID } };
+
+      // Default constructed broker.
+      Broker broker;
+
+      CHECK_FALSE(broker.accepts(MESSAGE1));
+      CHECK_FALSE(broker.accepts(MESSAGE2));
+      CHECK_FALSE(broker.accepts(MESSAGE3));
+      CHECK_FALSE(broker.accepts(MESSAGE4));
+      CHECK_FALSE(broker.accepts(MESSAGE5));
+      CHECK_FALSE(broker.accepts(MESSAGE6));
+
+      // Subscribe router1.
+      broker.subscribe(subscription1);
+      CHECK_TRUE(broker.accepts(MESSAGE1));
+      CHECK_FALSE(broker.accepts(MESSAGE2));
+      CHECK_TRUE(broker.accepts(MESSAGE3));
+      CHECK_FALSE(broker.accepts(MESSAGE4));
+      CHECK_FALSE(broker.accepts(MESSAGE5));
+      CHECK_FALSE(broker.accepts(MESSAGE6));
+
+      // Subscribe router2.
+      broker.subscribe(subscription2);
+      CHECK_TRUE(broker.accepts(MESSAGE1));
+      CHECK_TRUE(broker.accepts(MESSAGE2));
+      CHECK_TRUE(broker.accepts(MESSAGE3));
+      CHECK_TRUE(broker.accepts(MESSAGE4));
+      CHECK_FALSE(broker.accepts(MESSAGE5));
+      CHECK_FALSE(broker.accepts(MESSAGE6));
+
+      // Set router3 as a successor.
+      broker.set_successor(router3);
+      CHECK_TRUE(broker.accepts(MESSAGE1));
+      CHECK_TRUE(broker.accepts(MESSAGE2));
+      CHECK_TRUE(broker.accepts(MESSAGE3));
+      CHECK_TRUE(broker.accepts(MESSAGE4));
+      CHECK_TRUE(broker.accepts(MESSAGE5));
+      CHECK_TRUE(broker.accepts(MESSAGE6));
+    }
   };
 }
diff --git a/test/test_message_bus.cpp b/test/test_message_bus.cpp
index 9407ee36..e7fde856 100644
--- a/test/test_message_bus.cpp
+++ b/test/test_message_bus.cpp
@@ -45,7 +45,9 @@ namespace
     MESSAGE2,
     MESSAGE3,
     MESSAGE4,
-    MESSAGE5
+    MESSAGE5,
+    MESSAGE6,
+    MESSAGE7
   };
 
   enum
@@ -105,6 +107,14 @@ namespace
 
   Response response;
 
+  struct Message6 : public etl::message<MESSAGE6>
+  {
+  };
+
+  struct Message7 : public etl::message<MESSAGE7>
+  {
+  };
+
   int call_order;
 
   //***************************************************************************
@@ -224,6 +234,27 @@ namespace
     int message_unknown_count;
   };
 
+  //***************************************************************************
+  // Router that handles message 6 and returns nothing.
+  //***************************************************************************
+  class RouterC : public etl::message_router<RouterC, Message6>
+  {
+  public:
+
+    RouterC(etl::message_router_id_t id)
+      : message_router(id)
+    {
+    }
+
+    void on_receive(const Message6&)
+    {
+    }
+
+    void on_receive_unknown(const etl::imessage&)
+    {
+    }
+  };
+
   //***************************************************************************
   template <size_t Size>
   class MessageBus : public etl::message_bus<Size>
@@ -237,7 +268,7 @@ namespace
 
     using etl::message_bus<Size>::receive;
 
-    // Hook 'receive' to count the incomimg messages.
+    // Hook 'receive' to count the incoming messages.
     void receive(etl::message_router_id_t id, const etl::imessage& msg)
     {
       ++message_count;
@@ -951,5 +982,30 @@ namespace
 
       CHECK_EQUAL(1, bus.message_count);
     }
+
+    //*************************************************************************
+    TEST(message_bus_accepts)
+    {
+      MessageBus<2> bus1;
+      MessageBus<2> bus2;
+
+      RouterA router1(ROUTER1);
+      RouterB router2(ROUTER2);
+      RouterC router3(ROUTER3);
+
+      bus1.subscribe(router1);
+      bus1.subscribe(router2);
+      bus1.set_successor(bus2);
+
+      bus2.subscribe(router3);
+
+      CHECK_TRUE(bus1.accepts(MESSAGE1));
+      CHECK_TRUE(bus1.accepts(MESSAGE2));
+      CHECK_TRUE(bus1.accepts(MESSAGE3));
+      CHECK_TRUE(bus1.accepts(MESSAGE4));
+      CHECK_TRUE(bus1.accepts(MESSAGE5));
+      CHECK_TRUE(bus1.accepts(MESSAGE6));
+      CHECK_FALSE(bus1.accepts(MESSAGE7));
+    }
   };
 }
diff --git a/test/test_message_packet.cpp b/test/test_message_packet.cpp
index 6c7bda23..426c520c 100644
--- a/test/test_message_packet.cpp
+++ b/test/test_message_packet.cpp
@@ -194,6 +194,16 @@ namespace
 
   using Packet = etl::message_packet<Message1, Message2, Message3>;
 
+  struct Object
+  {
+    void Push(const etl::message_packet<Message1, Message2>& p)
+    {
+      ::new (buffer) etl::message_packet<Message1, Message2>(p);
+    }
+
+    char buffer[100];
+  };
+
   SUITE(test_message_packet)
   {
     //*************************************************************************
@@ -210,6 +220,7 @@ namespace
 
       // Should cause a static assert.
       //Packet packet4(message4);
+      //Packet packet4((Message4()));
 
       CHECK_EQUAL(MESSAGE1, packet1.get().get_message_id());
       CHECK_EQUAL(MESSAGE2, packet2.get().get_message_id());
@@ -445,13 +456,29 @@ namespace
       CHECK(Packet::accepts<Message2>());
       CHECK(Packet::accepts<Message3>());
       CHECK(!Packet::accepts<Message4>());
-
+       
       // From static message id.
       CHECK(Packet::accepts<MESSAGE1>());
       CHECK(Packet::accepts<MESSAGE2>());
       CHECK(Packet::accepts<MESSAGE3>());
       CHECK(!Packet::accepts<MESSAGE4>());
     }
+
+    //*************************************************************************
+    TEST(test_message_packet_push_to_queue_bug_845)
+    {
+      using Packet = etl::message_packet<Message1, Message2>;
+
+      Object obj;
+
+      Message1 message1(1);
+      Message2 message2(1.2);
+      Packet packet1(message1);
+      Packet packet2(message2);
+
+      obj.Push(packet1);
+      obj.Push(packet2);
+    }
   };
 }
 
diff --git a/test/test_message_timer.cpp b/test/test_message_timer.cpp
index 3f27e81e..0d5231f6 100644
--- a/test/test_message_timer.cpp
+++ b/test/test_message_timer.cpp
@@ -643,6 +643,40 @@ namespace
       CHECK_EQUAL(4, timer_controller.time_to_next());
     }
 
+    //*************************************************************************
+    TEST(message_timer_time_to_next_with_has_active_timer)
+    {
+      etl::message_timer<3> timer_controller;
+
+      etl::timer::id::type id1 = timer_controller.register_timer(message1, router1, 37, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id2 = timer_controller.register_timer(message2, router1, 23, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id3 = timer_controller.register_timer(message3, router1, 11, etl::timer::mode::Single_Shot);
+
+      router1.clear();
+
+      timer_controller.start(id1);
+      timer_controller.start(id3);
+      timer_controller.start(id2);
+
+      timer_controller.enable(true);
+
+      timer_controller.tick(11);
+      CHECK_EQUAL(12, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(23);
+      CHECK_EQUAL(3, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(2);
+      CHECK_EQUAL(1, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(1);
+      CHECK_EQUAL(static_cast<etl::timer::interval::type>(etl::timer::interval::No_Active_Interval), timer_controller.time_to_next());
+      CHECK_FALSE(timer_controller.has_active_timer());
+    }
+
     //*************************************************************************
 #if REALTIME_TEST
 
diff --git a/test/test_message_timer_atomic.cpp b/test/test_message_timer_atomic.cpp
index f8683f50..98a899ee 100644
--- a/test/test_message_timer_atomic.cpp
+++ b/test/test_message_timer_atomic.cpp
@@ -643,6 +643,40 @@ namespace
       CHECK_EQUAL(4, timer_controller.time_to_next());
     }
 
+    //*************************************************************************
+    TEST(message_timer_time_to_next_with_has_active_timer)
+    {
+      etl::message_timer_atomic<3, std::atomic_uint32_t> timer_controller;
+
+      etl::timer::id::type id1 = timer_controller.register_timer(message1, router1, 37, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id2 = timer_controller.register_timer(message2, router1, 23, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id3 = timer_controller.register_timer(message3, router1, 11, etl::timer::mode::Single_Shot);
+
+      router1.clear();
+
+      timer_controller.start(id1);
+      timer_controller.start(id3);
+      timer_controller.start(id2);
+
+      timer_controller.enable(true);
+
+      timer_controller.tick(11);
+      CHECK_EQUAL(12, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(23);
+      CHECK_EQUAL(3, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(2);
+      CHECK_EQUAL(1, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(1);
+      CHECK_EQUAL(static_cast<etl::timer::interval::type>(etl::timer::interval::No_Active_Interval), timer_controller.time_to_next());
+      CHECK_FALSE(timer_controller.has_active_timer());
+    }
+
     //*************************************************************************
 #if REALTIME_TEST
 
diff --git a/test/test_message_timer_interrupt.cpp b/test/test_message_timer_interrupt.cpp
index d1601bdb..e746644b 100644
--- a/test/test_message_timer_interrupt.cpp
+++ b/test/test_message_timer_interrupt.cpp
@@ -690,6 +690,40 @@ namespace
       CHECK_EQUAL(4, timer_controller.time_to_next());
     }
 
+    //*************************************************************************
+    TEST(message_timer_time_to_next_with_has_active_timer)
+    {
+      etl::message_timer_interrupt<3, ScopedGuard> timer_controller;
+
+      etl::timer::id::type id1 = timer_controller.register_timer(message1, router1, 37, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id2 = timer_controller.register_timer(message2, router1, 23, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id3 = timer_controller.register_timer(message3, router1, 11, etl::timer::mode::Single_Shot);
+
+      router1.clear();
+
+      timer_controller.start(id1);
+      timer_controller.start(id3);
+      timer_controller.start(id2);
+
+      timer_controller.enable(true);
+
+      timer_controller.tick(11);
+      CHECK_EQUAL(12, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(23);
+      CHECK_EQUAL(3, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(2);
+      CHECK_EQUAL(1, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(1);
+      CHECK_EQUAL(static_cast<etl::timer::interval::type>(etl::timer::interval::No_Active_Interval), timer_controller.time_to_next());
+      CHECK_FALSE(timer_controller.has_active_timer());
+    }
+
     //************************************************************************* 
     class RouterLog : public etl::message_router<RouterLog, Message1, Message2, Message3, Message4>
     {
diff --git a/test/test_message_timer_locked.cpp b/test/test_message_timer_locked.cpp
index 0e866be6..c3078c2d 100644
--- a/test/test_message_timer_locked.cpp
+++ b/test/test_message_timer_locked.cpp
@@ -770,6 +770,45 @@ namespace
       CHECK_EQUAL(4, timer_controller.time_to_next());
     }
 
+    //*************************************************************************
+    TEST(message_timer_time_to_next_with_has_active_timer)
+    {
+      locks.clear();
+      try_lock_type try_lock = try_lock_type::create<Locks, locks, &Locks::try_lock>();
+      lock_type     lock     = lock_type::create<Locks, locks, &Locks::lock>();
+      unlock_type   unlock   = unlock_type::create<Locks, locks, &Locks::unlock>();
+
+      etl::message_timer_locked<3> timer_controller(try_lock, lock, unlock);
+
+      etl::timer::id::type id1 = timer_controller.register_timer(message1, router1, 37, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id2 = timer_controller.register_timer(message2, router1, 23, etl::timer::mode::Single_Shot);
+      etl::timer::id::type id3 = timer_controller.register_timer(message3, router1, 11, etl::timer::mode::Single_Shot);
+
+      router1.clear();
+
+      timer_controller.start(id1);
+      timer_controller.start(id3);
+      timer_controller.start(id2);
+
+      timer_controller.enable(true);
+
+      timer_controller.tick(11);
+      CHECK_EQUAL(12, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(23);
+      CHECK_EQUAL(3, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(2);
+      CHECK_EQUAL(1, timer_controller.time_to_next());
+      CHECK_TRUE(timer_controller.has_active_timer());
+
+      timer_controller.tick(1);
+      CHECK_EQUAL(static_cast<etl::timer::interval::type>(etl::timer::interval::No_Active_Interval), timer_controller.time_to_next());
+      CHECK_FALSE(timer_controller.has_active_timer());
+    }
+
     //*************************************************************************
 #if REALTIME_TEST
 
diff --git a/test/test_multimap.cpp b/test/test_multimap.cpp
index afba0d69..a6a29e03 100644
--- a/test/test_multimap.cpp
+++ b/test/test_multimap.cpp
@@ -86,6 +86,7 @@ namespace
   SUITE(test_multimap)
   {
     //*************************************************************************
+#include "etl/private/diagnostic_null_dereference_push.h"
     template <typename T1, typename T2>
     bool Check_Equal(T1 begin1, T1 end1, T2 begin2)
     {
@@ -102,11 +103,12 @@ namespace
 
       return true;
     }
+#include "etl/private/diagnostic_null_dereference_push.h"
 
     //*************************************************************************
     struct SetupFixture
     {
-      // Multimaps of predefined data from which to constuct multimaps used in
+      // Multimaps of predefined data from which to construct multimaps used in
       // each test
       std::multimap<std::string, int> initial_data;
       std::multimap<std::string, int> excess_data;
@@ -276,10 +278,28 @@ namespace
 
       CHECK(!data1.empty()); // Move does not clear the source.
 
-      CHECK(1 == data2.find("1")->second.value);
-      CHECK(2 == data2.find("2")->second.value);
-      CHECK(3 == data2.find("3")->second.value);
-      CHECK(4 == data2.find("4")->second.value);
+      DataM::iterator itr;
+      int result;
+
+      itr = data2.find("1");
+      CHECK(itr != data2.end());
+      result = itr->second.value;
+      CHECK_EQUAL(1, result);
+
+      itr = data2.find("2");
+      CHECK(itr != data2.end());
+      result = itr->second.value;
+      CHECK_EQUAL(2, result);
+
+      itr = data2.find("3");
+      CHECK(itr != data2.end());
+      result = itr->second.value;
+      CHECK_EQUAL(3, result);
+
+      itr = data2.find("4");
+      CHECK(itr != data2.end());
+      result = itr->second.value;
+      CHECK_EQUAL(4, result);
     }
 
     //*************************************************************************
@@ -391,10 +411,28 @@ namespace
       data2.insert(DataM::value_type(std::string("5"), ItemM(5)));
       data2 = std::move(data1);
 
-      CHECK(1 == data2.find("1")->second.value);
-      CHECK(2 == data2.find("2")->second.value);
-      CHECK(3 == data2.find("3")->second.value);
-      CHECK(4 == data2.find("4")->second.value);
+      DataM::iterator itr;
+      int result;
+
+      itr = data2.find("1");
+      CHECK(itr != data2.end());
+      result = itr->second.value;
+      CHECK_EQUAL(1, result);
+
+      itr = data2.find("2");
+      CHECK(itr != data2.end());
+      result = itr->second.value;
+      CHECK_EQUAL(2, result);
+
+      itr = data2.find("3");
+      CHECK(itr != data2.end());
+      result = itr->second.value;
+      CHECK_EQUAL(3, result);
+
+      itr = data2.find("4");
+      CHECK(itr != data2.end());
+      result = itr->second.value;
+      CHECK_EQUAL(4, result);
     }
 
     //*************************************************************************
@@ -1577,7 +1615,10 @@ namespace
           break;
         }
 
-        prv = pos->first;
+        if (pos != data.crend())
+        {
+          prv = pos->first;
+        }
       }
 
       CHECK(pass);
diff --git a/test/test_multiset.cpp b/test/test_multiset.cpp
index 45d98fab..cb64956c 100644
--- a/test/test_multiset.cpp
+++ b/test/test_multiset.cpp
@@ -101,6 +101,7 @@ namespace
   SUITE(test_multiset)
   {
     //*************************************************************************
+#include "etl/private/diagnostic_null_dereference_push.h"
     template <typename T1, typename T2>
     bool Check_Equal(T1 begin1, T1 end1, T2 begin2)
     {
@@ -117,11 +118,12 @@ namespace
 
       return true;
     }
+#include "etl/private/diagnostic_pop.h"
 
     //*************************************************************************
     struct SetupFixture
     {
-      // Multisets of predefined data from which to constuct multisets used in
+      // Multisets of predefined data from which to construct multisets used in
       // each test
       std::multiset<int> initial_data;
       std::multiset<int> excess_data;
@@ -1157,7 +1159,12 @@ namespace
 
       i_compare = compare_data.lower_bound(99);
       i_data = data.lower_bound(99);
-      CHECK(*i_compare == *i_data);
+      CHECK(i_data != data.end());
+      
+      if ((i_data != data.end()) && (i_compare != compare_data.end()))
+      {
+        CHECK(*i_compare == *i_data);
+      }
 #else
       i_compare = compare_data.lower_bound(-1);
       i_data = data.lower_bound(-1);
@@ -1214,7 +1221,12 @@ namespace
 
       i_compare = compare_data.lower_bound(99);
       i_data = data.lower_bound(99);
-      CHECK(*i_compare == *i_data);
+      CHECK(i_data != data.end());
+
+      if ((i_data != data.end()) && (i_compare != compare_data.end()))
+      {
+        CHECK(*i_compare == *i_data);
+      }
 #else
       i_compare = compare_data.lower_bound(-1);
       i_data = data.lower_bound(-1);
@@ -1271,7 +1283,12 @@ namespace
 
       i_compare = compare_data.upper_bound(99);
       i_data = data.upper_bound(99);
-      CHECK(*i_compare == *i_data);
+      CHECK(i_data != data.end());
+
+      if ((i_data != data.end()) && (i_compare != compare_data.end()))
+      {
+        CHECK(*i_compare == *i_data);
+      }
 #else
       i_compare = compare_data.upper_bound(-1);
       i_data = data.upper_bound(-1);
@@ -1328,7 +1345,12 @@ namespace
 
       i_compare = compare_data.upper_bound(99);
       i_data = data.upper_bound(99);
-      CHECK(*i_compare == *i_data);
+      CHECK(i_data != data.end());
+
+      if ((i_data != data.end()) && (i_compare != compare_data.end()))
+      {
+        CHECK(*i_compare == *i_data);
+      }
 #else
       i_compare = compare_data.upper_bound(-1);
       i_data = data.upper_bound(-1);
@@ -1444,7 +1466,7 @@ namespace
             if((compare.lower_bound(i) == compare.end()) == (data.lower_bound(i) == data.end()))
             {
                 //if both are not end
-                if(compare.lower_bound(i) != compare.end())
+                if ((data.lower_bound(i) != data.end()) && (compare.lower_bound(i) != compare.end()))
                 {
                     CHECK((*compare.lower_bound(i)) == (*data.lower_bound(i)));
                 }
@@ -1467,10 +1489,10 @@ namespace
             //upper_bound
             CHECK_EQUAL(compare.upper_bound(i) == compare.end(), data.upper_bound(i) == data.end());
             //if both end, or none
-            if((compare.upper_bound(i) == compare.end()) == (data.upper_bound(i) == data.end()))
+            if ((compare.upper_bound(i) == compare.end()) == (data.upper_bound(i) == data.end()))
             {
                 //if both are not end
-                if(compare.upper_bound(i) != compare.end())
+                if ((data.upper_bound(i) != data.end()) && (compare.upper_bound(i) != compare.end()))
                 {
                     CHECK((*compare.upper_bound(i)) == (*data.upper_bound(i)));
                 }
@@ -1506,7 +1528,7 @@ namespace
         if ((compare.lower_bound(i) == compare.end()) == (data.lower_bound(i) == data.end()))
         {
           //if both are not end
-          if (compare.lower_bound(i) != compare.end())
+          if ((data.lower_bound(i) != data.end()) && (compare.lower_bound(i) != compare.end()))
           {
             CHECK((*compare.lower_bound(i)) == (*data.lower_bound(i)));
           }
@@ -1532,7 +1554,7 @@ namespace
         if ((compare.upper_bound(i) == compare.end()) == (data.upper_bound(i) == data.end()))
         {
           //if both are not end
-          if (compare.upper_bound(i) != compare.end())
+          if ((data.upper_bound(i) != data.end()) && (compare.upper_bound(i) != compare.end()))
           {
             CHECK((*compare.upper_bound(i)) == (*data.upper_bound(i)));
           }
@@ -1563,6 +1585,7 @@ namespace
 
       for (pos = data.crbegin(); pos != data.crend(); ++pos)
       {
+#include "etl/private/diagnostic_null_dereference_push.h"
         if (*pos > prv)
         {
           pass = false;
@@ -1570,6 +1593,7 @@ namespace
         }
 
         prv = *pos;
+#include "etl/private/diagnostic_pop.h"
       }
 
       CHECK(pass);
diff --git a/test/test_optional.cpp b/test/test_optional.cpp
index 8f07862b..61e68672 100644
--- a/test/test_optional.cpp
+++ b/test/test_optional.cpp
@@ -53,6 +53,28 @@ std::ostream& operator << (std::ostream& os, const etl::optional<Data>& data)
 
 namespace
 {
+#include "etl/private/diagnostic_unused_function_push.h"
+  //*************************************************************************
+  struct NonTrivial
+  {
+    constexpr NonTrivial() : a(0) {}
+
+    constexpr NonTrivial(int a_) : a(a_) {}
+
+    constexpr friend bool operator <(const NonTrivial& lhs, const NonTrivial& rhs)
+    {
+      return lhs.a < rhs.a;
+    }
+
+    constexpr friend bool operator ==(const NonTrivial& lhs, const NonTrivial& rhs)
+    {
+      return lhs.a == rhs.a;
+    }
+
+    int a;
+  };
+#include "etl/private/diagnostic_pop.h"
+
   SUITE(test_optional)
   {
     //*************************************************************************
@@ -153,10 +175,19 @@ namespace
 #include "etl/private/diagnostic_pop.h"
     }
 
+    //*************************************************************************
+    TEST(test_nullopt_pod)
+    {
+      etl::optional<int> data(etl::nullopt);
+      data = 1;
+      data = etl::nullopt;
+      CHECK(!bool(data));
+    }
+
     //*************************************************************************
     TEST(test_nullopt)
     {
-      etl::optional<Data> data;
+      etl::optional<Data> data(etl::nullopt);
       data = Data("Hello");
       data = etl::nullopt;
       CHECK(!bool(data));
@@ -239,6 +270,40 @@ namespace
       CHECK(!(Data("Data2") == data1));
     }
 
+#if ETL_USING_CPP20 && ETL_USING_STL
+    //*************************************************************************
+    TEST(test_constexpr_equality_non_trivial)
+    {
+      constexpr etl::optional<NonTrivial> data1(1);
+      constexpr etl::optional<NonTrivial> data2(2);
+
+      constexpr bool eq1 = (data1 == data2);
+      constexpr bool eq2 = (data1 == etl::nullopt);
+      constexpr bool eq3 = (etl::nullopt == data1);
+
+      CHECK_FALSE(eq1);
+      CHECK_FALSE(eq2);
+      CHECK_FALSE(eq3);
+    }
+#endif
+
+#if ETL_USING_CPP14
+    //*************************************************************************
+    TEST(test_constexpr_equality_trivial)
+    {
+      constexpr etl::optional<int> data1(1);
+      constexpr etl::optional<int> data2(2);
+
+      constexpr bool eq1 = (data1 == data2);
+      constexpr bool eq2 = (data1 == etl::nullopt);
+      constexpr bool eq3 = (etl::nullopt == data1);
+
+      CHECK_FALSE(eq1);
+      CHECK_FALSE(eq2);
+      CHECK_FALSE(eq3);
+    }
+#endif
+
     //*************************************************************************
     TEST(test_inequality)
     {
@@ -276,6 +341,40 @@ namespace
       CHECK(Data("Data2") != data1);
     }
 
+#if ETL_USING_CPP20 && ETL_USING_STL
+    //*************************************************************************
+    TEST(test_constexpr_inequality_non_trivial)
+    {
+      constexpr etl::optional<NonTrivial> data1(1);
+      constexpr etl::optional<NonTrivial> data2(2);
+
+      constexpr bool eq1 = (data1 != data2);
+      constexpr bool eq2 = (data1 != etl::nullopt);
+      constexpr bool eq3 = (etl::nullopt != data1);
+
+      CHECK_TRUE(eq1);
+      CHECK_TRUE(eq2);
+      CHECK_TRUE(eq3);
+    }
+#endif
+
+#if ETL_USING_CPP14
+    //*************************************************************************
+    TEST(test_constexpr_inequality_trivial)
+    {
+      constexpr etl::optional<int> data1(1);
+      constexpr etl::optional<int> data2(2);
+
+      constexpr bool neq1 = (data1 != data2);
+      constexpr bool neq2 = (data1 != etl::nullopt);
+      constexpr bool neq3 = (etl::nullopt != data1);
+
+      CHECK_TRUE(neq1);
+      CHECK_TRUE(neq2);
+      CHECK_TRUE(neq3);
+    }
+#endif
+
     //*************************************************************************
 #include "etl/private/diagnostic_uninitialized_push.h"
     TEST(test_less_than)
@@ -310,6 +409,45 @@ namespace
     }
 #include "etl/private/diagnostic_pop.h"
 
+
+#if ETL_USING_CPP20 && ETL_USING_STL
+    //*************************************************************************
+    TEST(test_constexpr_less_than_non_trivial)
+    {
+      constexpr etl::optional<NonTrivial> data1(1);
+      constexpr etl::optional<NonTrivial> data2(2);
+
+      constexpr bool lt1 = (data1 < data2);
+      constexpr bool lt2 = (data2 < data1);
+      constexpr bool lt3 = (data1 < etl::nullopt);
+      constexpr bool lt4 = (etl::nullopt < data1);
+
+      CHECK_TRUE(lt1);
+      CHECK_FALSE(lt2);
+      CHECK_FALSE(lt3);
+      CHECK_TRUE(lt4);
+    }
+#endif
+
+#if ETL_USING_CPP14
+    //*************************************************************************
+    TEST(test_constexpr_less_than_trivial)
+    {
+      constexpr etl::optional<int> data1(1);
+      constexpr etl::optional<int> data2(2);
+
+      constexpr bool lt1 = (data1 < data2);
+      constexpr bool lt2 = (data2 < data1);
+      constexpr bool lt3 = (data1 < etl::nullopt);
+      constexpr bool lt4 = (etl::nullopt < data1);
+
+      CHECK_TRUE(lt1);
+      CHECK_FALSE(lt2);
+      CHECK_FALSE(lt3);
+      CHECK_TRUE(lt4);
+    }
+#endif
+
     //*************************************************************************
     TEST(test_less_than_equal)
     {
@@ -344,6 +482,44 @@ namespace
       CHECK(Data("Data1") <= data1);
     }
 
+#if ETL_USING_CPP20 && ETL_USING_STL
+    //*************************************************************************
+    TEST(test_constexpr_less_than_equal_non_trivial)
+    {
+      constexpr etl::optional<NonTrivial> data1(1);
+      constexpr etl::optional<NonTrivial> data2(2);
+
+      constexpr bool lt1 = (data1 <= data2);
+      constexpr bool lt2 = (data2 <= data1);
+      constexpr bool lt3 = (data1 <= etl::nullopt);
+      constexpr bool lt4 = (etl::nullopt <= data1);
+
+      CHECK_TRUE(lt1);
+      CHECK_FALSE(lt2);
+      CHECK_FALSE(lt3);
+      CHECK_TRUE(lt4);
+    }
+#endif
+
+#if ETL_USING_CPP14
+    //*************************************************************************
+    TEST(test_constexpr_less_than_equal_trivial)
+    {
+      constexpr etl::optional<int> data1(1);
+      constexpr etl::optional<int> data2(2);
+
+      constexpr bool lt1 = (data1 <= data2);
+      constexpr bool lt2 = (data2 <= data1);
+      constexpr bool lt3 = (data1 <= etl::nullopt);
+      constexpr bool lt4 = (etl::nullopt <= data1);
+
+      CHECK_TRUE(lt1);
+      CHECK_FALSE(lt2);
+      CHECK_FALSE(lt3);
+      CHECK_TRUE(lt4);
+    }
+#endif
+
     //*************************************************************************
     TEST(test_greater_than)
     {
@@ -376,6 +552,44 @@ namespace
       CHECK(!(Data("Data1") > data2));
     }
 
+#if ETL_USING_CPP20 && ETL_USING_STL
+    //*************************************************************************
+    TEST(test_constexpr_greater_than_non_trivial)
+    {
+      constexpr etl::optional<NonTrivial> data1(1);
+      constexpr etl::optional<NonTrivial> data2(2);
+
+      constexpr bool gt1 = (data1 > data2);
+      constexpr bool gt2 = (data2 > data1);
+      constexpr bool gt3 = (data1 > etl::nullopt);
+      constexpr bool gt4 = (etl::nullopt > data1);
+
+      CHECK_FALSE(gt1);
+      CHECK_TRUE(gt2);
+      CHECK_TRUE(gt3);
+      CHECK_FALSE(gt4);
+    }
+#endif
+
+#if ETL_USING_CPP14
+    //*************************************************************************
+    TEST(test_constexpr_greater_than_trivial)
+    {
+      constexpr etl::optional<int> data1(1);
+      constexpr etl::optional<int> data2(2);
+
+      constexpr bool gt1 = (data1 > data2);
+      constexpr bool gt2 = (data2 > data1);
+      constexpr bool gt3 = (data1 > etl::nullopt);
+      constexpr bool gt4 = (etl::nullopt > data1);
+
+      CHECK_FALSE(gt1);
+      CHECK_TRUE(gt2);
+      CHECK_TRUE(gt3);
+      CHECK_FALSE(gt4);
+    }
+#endif
+
     //*************************************************************************
     TEST(test_greater_than_equal)
     {
@@ -410,6 +624,44 @@ namespace
       CHECK(Data("Data1") >= data1);
     }
 
+#if ETL_USING_CPP20 && ETL_USING_STL
+    //*************************************************************************
+    TEST(test_constexpr_greater_than_equal_non_trivial)
+    {
+      constexpr etl::optional<NonTrivial> data1(1);
+      constexpr etl::optional<NonTrivial> data2(2);
+
+      constexpr bool gte1 = (data1 >= data2);
+      constexpr bool gte2 = (data2 >= data1);
+      constexpr bool gte3 = (data1 >= etl::nullopt);
+      constexpr bool gte4 = (etl::nullopt >= data1);
+
+      CHECK_FALSE(gte1);
+      CHECK_TRUE(gte2);
+      CHECK_TRUE(gte3);
+      CHECK_FALSE(gte4);
+    }
+#endif
+
+#if ETL_USING_CPP14
+    //*************************************************************************
+    TEST(test_constexpr_greater_than_equal_trivial)
+    {
+      constexpr etl::optional<int> data1(1);
+      constexpr etl::optional<int> data2(2);
+
+      constexpr bool gte1 = (data1 >= data2);
+      constexpr bool gte2 = (data2 >= data1);
+      constexpr bool gte3 = (data1 >= etl::nullopt);
+      constexpr bool gte4 = (etl::nullopt >= data1);
+
+      CHECK_FALSE(gte1);
+      CHECK_TRUE(gte2);
+      CHECK_TRUE(gte3);
+      CHECK_FALSE(gte4);
+    }
+#endif
+
     //*************************************************************************
     TEST(test_container_of_optional)
     {
@@ -629,6 +881,21 @@ namespace
       CHECK_EQUAL(42, (*opt).v);
     }
 #endif
+
+    //*************************************************************************
+    TEST(test_optional_issue_819)
+    {
+      // The code below should compile without error.
+      class optional_type 
+      {
+      public:
+
+        static etl::optional<optional_type> function()
+        {
+          return {};
+        }
+      };
+    }
   };
 }
 
diff --git a/test/test_parameter_type.cpp b/test/test_parameter_type.cpp
index 5b30bdaa..3075f3cc 100644
--- a/test/test_parameter_type.cpp
+++ b/test/test_parameter_type.cpp
@@ -35,17 +35,17 @@ SOFTWARE.
 
 namespace
 {
-  class Test
+  class Object
   {
   public:
 
-    Test()
+    Object()
       : p(new int())
     {
       *p = 4;
     }
 
-    ~Test()
+    ~Object()
     {
       delete p;
     }
@@ -53,18 +53,18 @@ namespace
     int* p;
   };
 
-  class Test2 : public Test
+  class Object2 : public Object
   {
   };
 }
 
 namespace etl
 {
-  // Test2 is a value parameter type.
+  // Object2 is a value parameter type.
   template <>
-  struct parameter_type<Test2>
+  struct parameter_type<Object2>
   {
-    typedef Test2 type;
+    typedef Object2 type;
   };
 }
 
@@ -80,10 +80,10 @@ namespace
       b = !etl::is_reference<etl::parameter_type<int>::type>::value;
       CHECK(b);
 
-      b = etl::is_reference<etl::parameter_type<Test>::type>::value;
+      b = etl::is_reference<etl::parameter_type<Object>::type>::value;
       CHECK(b);
 
-      b = !etl::is_reference<etl::parameter_type<Test2>::type>::value;
+      b = !etl::is_reference<etl::parameter_type<Object2>::type>::value;
       CHECK(b);
     }
   };
diff --git a/test/test_pool.cpp b/test/test_pool.cpp
index 10fd4cbd..48f2881a 100644
--- a/test/test_pool.cpp
+++ b/test/test_pool.cpp
@@ -352,7 +352,7 @@ namespace
     //*************************************************************************
     TEST(test_type_error)
     {
-      struct Test
+      struct Object
       {
         uint64_t a;
         uint64_t b;
@@ -362,7 +362,7 @@ namespace
 
       etl::ipool& ip = pool;
 
-      CHECK_THROW(ip.allocate<Test>(), etl::pool_element_size);
+      CHECK_THROW(ip.allocate<Object>(), etl::pool_element_size);
     }
 
     //*************************************************************************
diff --git a/test/test_pool_external_buffer.cpp b/test/test_pool_external_buffer.cpp
index 9723abe3..6b3851ce 100644
--- a/test/test_pool_external_buffer.cpp
+++ b/test/test_pool_external_buffer.cpp
@@ -388,7 +388,7 @@ namespace
     //*************************************************************************
     TEST(test_type_error)
     {
-      struct Test
+      struct Object
       {
         uint64_t a;
         uint64_t b;
@@ -400,7 +400,7 @@ namespace
 
       etl::ipool& ip = pool;
 
-      CHECK_THROW(ip.allocate<Test>(), etl::pool_element_size);
+      CHECK_THROW(ip.allocate<Object>(), etl::pool_element_size);
 
       delete[] buffer;
     }
diff --git a/test/test_set.cpp b/test/test_set.cpp
index bf9fc7a8..a8d93776 100644
--- a/test/test_set.cpp
+++ b/test/test_set.cpp
@@ -106,6 +106,7 @@ namespace
   SUITE(test_set)
   {
     //*************************************************************************
+#include "etl/private/diagnostic_null_dereference_push.h"
     template <typename T1, typename T2>
     bool Check_Equal(T1 begin1, T1 end1, T2 begin2)
     {
@@ -122,6 +123,7 @@ namespace
 
       return true;
     }
+#include "etl/private/diagnostic_pop.h"
 
     //*************************************************************************
     struct SetupFixture
@@ -612,12 +614,7 @@ namespace
       }
 
       // Try to insert when set is full should throw etl::set_full
-      try
-      {
-        data_result = data.insert(MAX_SIZE);
-      }
-      catch(const etl::set_full &e)
-      {}
+      CHECK_THROW(data_result = data.insert(MAX_SIZE), etl::set_full);
 
       // Try adding a duplicate (should return iterator pointing to duplicate) not throw error
       for (size_t i = 0; i < MAX_SIZE; ++i)
@@ -639,7 +636,7 @@ namespace
 
     }
 
-    //*************************************************************************
+    ////*************************************************************************
     //TEST_FIXTURE(SetupFixture, test_emplace_value)
     //{
     //  Compare_Data compare_data;
@@ -1036,7 +1033,12 @@ namespace
 
       i_compare = compare_data.lower_bound(11);
       i_data = data.lower_bound(11);
-      CHECK(*i_compare == *i_data);
+      CHECK(i_data != data.end());
+
+      if ((i_data != data.end()) && (i_compare != compare_data.end()))
+      {
+        CHECK(*i_compare == *i_data);
+      }
 #else
       i_compare = compare_data.lower_bound(-1);
       i_data = data.lower_bound(-1);
diff --git a/test/test_shared_message.cpp b/test/test_shared_message.cpp
index 749c7822..0ac310e0 100644
--- a/test/test_shared_message.cpp
+++ b/test/test_shared_message.cpp
@@ -44,12 +44,37 @@ namespace
   constexpr etl::message_router_id_t RouterId1 = 1U;
   constexpr etl::message_router_id_t RouterId2 = 2U;
 
+  int message_1_instantiations = 0;
+
   //*************************************************************************
   struct Message1 : public etl::message<MessageId1>
   {
-    Message1(int i_)
-      : i(i_)
+    Message1()
+      : message()
+      , i(0)
     {
+      ++message_1_instantiations;
+    }
+
+    Message1(int i_)
+      : message()
+      , i(i_)
+    {
+      ++message_1_instantiations;
+    }
+
+    Message1(const Message1& msg)
+      : message()
+      , i(msg.i)
+    {
+      ++message_1_instantiations;
+    }
+
+    Message1(Message1&& msg)
+      : message()
+      , i(msg.i)
+    {
+      ++message_1_instantiations;
     }
 
     ~Message1()
@@ -155,9 +180,24 @@ namespace
 
     etl::fixed_sized_memory_block_allocator<pool_message_parameters::max_size,
                                             pool_message_parameters::max_alignment,
-                                            4U> memory_allocator;
+                                            4U> common_memory_allocator;
 
-    etl::atomic_counted_message_pool message_pool(memory_allocator);
+    class atomic_counted_message_factory : public etl::atomic_counted_message_pool
+    {
+      public:
+        atomic_counted_message_factory(etl::imemory_block_allocator& memory_block_allocator_)
+          : etl::atomic_counted_message_pool(memory_block_allocator_)
+        {
+        }
+
+        template <typename TMessage, typename... Args>
+        etl::shared_message create_message(Args&&... args)
+        {
+          return etl::shared_message::create<TMessage>(*this, etl::forward<Args>(args)...);
+        }
+    };
+
+    atomic_counted_message_factory common_message_pool(common_memory_allocator);
 
     //*************************************************************************
     class Message2Allocator : public etl::ireference_counted_message_pool
@@ -180,17 +220,65 @@ namespace
     };
 
     //*************************************************************************
-    TEST(test_move_constructor)
+    TEST(test_move_constructor_with_default_constructed_message)
+    {
+      etl::fixed_sized_memory_block_allocator<pool_message_parameters::max_size,
+                                              pool_message_parameters::max_alignment, 4U> memory_allocator;
+
+      etl::atomic_counted_message_pool message_pool(memory_allocator);
+
+#include "etl/private/diagnostic_pessimizing_move_push.h"
+      etl::shared_message sm(std::move(etl::shared_message(message_pool, Message1())));
+#include "etl/private/diagnostic_pop.h"
+
+      CHECK_EQUAL(1, sm.get_reference_count());
+    }
+
+    //*************************************************************************
+    TEST(test_move_constructor_with_default_constructed_message_inplace_in_message_pool)
+    {
+      message_1_instantiations = 0;
+
+#include "etl/private/diagnostic_pessimizing_move_push.h"
+      etl::shared_message sm (std::move(common_message_pool.create_message<Message1>()));
+#include "etl/private/diagnostic_pop.h"
+
+      CHECK_EQUAL(1, sm.get_reference_count());
+      CHECK_EQUAL(1, message_1_instantiations);
+    }
+
+    //*************************************************************************
+    TEST(test_move_constructor_with_parametrized_constructed_message)
     {
 #include "etl/private/diagnostic_pessimizing_move_push.h"
-      etl::shared_message sm1(std::move(etl::shared_message(message_pool, Message1(1))));
+      etl::shared_message sm(std::move(etl::shared_message(common_message_pool, Message1(1))));
 #include "etl/private/diagnostic_pop.h"
-      CHECK_EQUAL(1, sm1.get_reference_count());
+
+      CHECK_EQUAL(1, sm.get_reference_count());
+    }
+
+    //*************************************************************************
+    TEST(test_move_constructor_with_parametrized_constructed_message_inplace_in_message_pool)
+    {
+      message_1_instantiations = 0;
+
+#include "etl/private/diagnostic_pessimizing_move_push.h"
+      etl::shared_message sm (std::move(common_message_pool.create_message<Message1>(1)));
+#include "etl/private/diagnostic_pop.h"
+
+      CHECK_EQUAL(1, sm.get_reference_count());
+      CHECK_EQUAL(1, message_1_instantiations);
     }
 
     //*************************************************************************
     TEST(test_default_message_constructor)
     {
+      etl::fixed_sized_memory_block_allocator<pool_message_parameters::max_size,
+                                              pool_message_parameters::max_alignment, 
+                                              4U> memory_allocator;
+
+      etl::atomic_counted_message_pool message_pool(memory_allocator);
+
       etl::reference_counted_message<Message2, etl::atomic_int>* prcm = message_pool.allocate<Message2>();
 
       Message2&        m2 = prcm->get_message(); // Check that we can get a non-const reference to the message.
@@ -214,6 +302,12 @@ namespace
     //*************************************************************************
     TEST(test_move_assignment)
     {
+      etl::fixed_sized_memory_block_allocator<pool_message_parameters::max_size,
+                                              pool_message_parameters::max_alignment, 
+                                              4U> memory_allocator;
+
+      etl::atomic_counted_message_pool message_pool(memory_allocator);
+
       etl::shared_message sm2 = etl::shared_message(message_pool, Message1(2));
 #include "etl/private/diagnostic_pessimizing_move_push.h"
       sm2 = std::move(etl::shared_message(message_pool, Message1(3)));
@@ -231,6 +325,12 @@ namespace
       router1.clear();
       router2.clear();
 
+      etl::fixed_sized_memory_block_allocator<pool_message_parameters::max_size,
+                                              pool_message_parameters::max_alignment, 
+                                              4U> memory_allocator;
+
+      etl::atomic_counted_message_pool message_pool(memory_allocator);
+
       etl::shared_message sm1(message_pool, Message1(1)); // sm1 holds a Message1 that is owned by message_pool.
       etl::shared_message sm2(message_pool, Message2());  // sm2 holds a Message2 that is owned by message_pool.
       etl::shared_message sm3(Message2Allocator::Get());  // sm3 holds a Message2 that is owned by a statically allocated message pool.
@@ -263,8 +363,6 @@ namespace
     //*************************************************************************
     TEST(test_reference_counted_pool_exceptions)
     {
-      using pool_message_parameters = etl::atomic_counted_message_pool::pool_message_parameters<Message1, Message2>;
-
       etl::fixed_sized_memory_block_allocator<pool_message_parameters::max_size,
                                               pool_message_parameters::max_alignment,
                                               4U> memory_allocator;
@@ -278,27 +376,12 @@ namespace
       CHECK_NO_THROW(prcm = message_pool.allocate<Message1>(4));
       
       (void)prcm;
-
-      try
-      {
-        prcm = message_pool.allocate<Message1>(5);
-      }
-      catch (etl::exception e)
-      {
-        CHECK_EQUAL(std::string("reference_counted_message_pool:allocation failure"), std::string(e.what()));
-      }
+      CHECK_THROW(prcm = message_pool.allocate<Message1>(5), etl::reference_counted_message_pool_allocation_failure);
       
       Message1 message1(6);
       etl::reference_counted_message<Message1, etl::atomic_int> temp(message1, message_pool);
 
-      try
-      {
-        message_pool.release(temp);
-      }
-      catch (etl::exception e)
-      {
-        CHECK_EQUAL(std::string("reference_counted_message_pool:release failure"), std::string(e.what()));
-      }
+      CHECK_THROW(message_pool.release(temp), etl::reference_counted_message_pool_release_failure);
     }
   }
-}
+}
\ No newline at end of file
diff --git a/test/test_span_fixed_extent.cpp b/test/test_span_fixed_extent.cpp
index 001086bb..b59237c1 100644
--- a/test/test_span_fixed_extent.cpp
+++ b/test/test_span_fixed_extent.cpp
@@ -76,16 +76,6 @@ namespace
     const int ccdata[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
     const int* pccdata = ccdata;
 
-    //*************************************************************************
-    TEST(test_default_constructor)
-    {
-      View view;
-
-      CHECK_EQUAL(10U, view.size());
-      CHECK_EQUAL(10U, view.max_size());
-      CHECK(!view.empty());
-    }
-
 #if ETL_USING_CPP20
     //*************************************************************************
     TEST(test_construct_from_std_span)
@@ -272,9 +262,7 @@ namespace
     //*************************************************************************
     TEST(test_implicit_constructor_c_array_2)
     {
-      CView view;
-
-      view = ccdata;
+      CView view(ccdata);
 
       CHECK_EQUAL(SIZE, view.size());
       CHECK_EQUAL(SIZE, view.max_size());
@@ -362,12 +350,11 @@ namespace
     TEST(test_assign_from_span)
     {
       View view1(etldata);
-      View view2;
+      View view2 = view1;
 
       CView cview1(etldata);
-      CView cview2;
+      CView cview2 = view2;
 
-      view2 = view1;
       cview2 = cview1;
 
       CHECK_EQUAL(view1.size(), view2.size());
@@ -1027,22 +1014,16 @@ namespace
       View view2{ data1 };
       View view3{ data2 };
       View view4{ data3 };
-      View view6;
-      View view7;
       SView view8{ data4 };
 
       CHECK_TRUE(etl::equal(view1, view2));
       CHECK_TRUE(etl::equal(view1, view3));
       CHECK_FALSE(etl::equal(view1, view4));
-      CHECK_TRUE(etl::equal(view6, view6));
-      CHECK_TRUE(etl::equal(view6, view7));
       CHECK_FALSE(etl::equal(view1, view8));
 
       CHECK_TRUE(view1 == view2);
       CHECK_FALSE(view1 == view3);
       CHECK_FALSE(view1 == view4);
-      CHECK_TRUE(view6 == view6);
-      CHECK_TRUE(view6 == view7);
       CHECK_FALSE(view1 == view8);
     }
 
@@ -1057,20 +1038,14 @@ namespace
       CView view2{ data1 };
       CView view3{ data2 };
       CView view4{ data3 };
-      View view6;
-      CView view7;
 
       CHECK_TRUE(etl::equal(view1, view2));
       CHECK_TRUE(etl::equal(view1, view3));
       CHECK_FALSE(etl::equal(view1, view4));
-      CHECK_TRUE(etl::equal(view6, view6));
-      CHECK_TRUE(etl::equal(view6, view7));
 
       CHECK_TRUE(view1 == view2);
       CHECK_FALSE(view1 == view3);
       CHECK_FALSE(view1 == view4);
-      CHECK_TRUE(view6 == view6);
-      CHECK_TRUE(view6 == view7);
     }
 
     //*************************************************************************
@@ -1084,20 +1059,14 @@ namespace
       View view2{ data1 };
       View view3{ data2 };
       View view4{ data3 };
-      View view6;
-      View view7;
 
       CHECK_TRUE(etl::equal(view1, view2));
       CHECK_TRUE(etl::equal(view1, view3));
       CHECK_FALSE(etl::equal(view1, view4));
-      CHECK_TRUE(etl::equal(view6, view6));
-      CHECK_TRUE(etl::equal(view6, view7));
 
       CHECK_FALSE(view1 != view2);
       CHECK_TRUE(view1 != view3);
       CHECK_TRUE(view1 != view4);
-      CHECK_FALSE(view6 != view6);
-      CHECK_FALSE(view6 != view7);
     }
 
     //*************************************************************************
@@ -1111,20 +1080,14 @@ namespace
       CView view2{ data1 };
       CView view3{ data2 };
       CView view4{ data3 };
-      View view6;
-      View view7;
 
       CHECK_TRUE(etl::equal(view1, view2));
       CHECK_TRUE(etl::equal(view1, view3));
       CHECK_FALSE(etl::equal(view1, view4));
-      CHECK_TRUE(etl::equal(view6, view6));
-      CHECK_TRUE(etl::equal(view6, view7));
 
       CHECK_FALSE(view1 != view2);
       CHECK_TRUE(view1 != view3);
       CHECK_TRUE(view1 != view4);
-      CHECK_FALSE(view6 != view6);
-      CHECK_FALSE(view6 != view7);
     }
 
     //*************************************************************************
diff --git a/test/test_type_def.cpp b/test/test_type_def.cpp
index 5cf9203b..b30278a9 100644
--- a/test/test_type_def.cpp
+++ b/test/test_type_def.cpp
@@ -32,6 +32,8 @@ SOFTWARE.
 
 #include "etl/type_def.h"
 
+#include "etl/type_traits.h"
+
 namespace
 {
   SUITE(test_type_def)
@@ -51,6 +53,21 @@ namespace
       CHECK_EQUAL(i1, i2);
     }
 
+    //*************************************************************************
+    TEST(test_macro_constexpr)
+    {
+      ETL_TYPEDEF(uint32_t, type1_t);
+      ETL_TYPEDEF(uint32_t, type2_t);
+
+      constexpr type1_t t1 = type1_t(1);
+      constexpr type2_t t2 = type2_t(1);
+
+      uint32_t i1 = t1.get();
+      uint32_t i2 = t2.get();
+
+      CHECK_EQUAL(i1, i2);
+    }
+
     //*************************************************************************
     TEST(test_implicit)
     {
@@ -69,6 +86,24 @@ namespace
       CHECK_EQUAL(i1, i2);
     }
 
+    //*************************************************************************
+    TEST(test_implicit_constexpr)
+    {
+      class type1_t_tag;
+      typedef etl::type_def<type1_t_tag, uint32_t> type1_t;
+
+      class type2_t_tag;
+      typedef etl::type_def<type2_t_tag, uint32_t> type2_t;
+
+      constexpr type1_t t1 = type1_t(1);
+      constexpr type2_t t2 = type2_t(1);
+
+      uint32_t i1 = t1.get();
+      uint32_t i2 = t2.get();
+
+      CHECK_EQUAL(i1, i2);
+    }
+
     //*************************************************************************
     TEST(test_get)
     {
@@ -84,6 +119,21 @@ namespace
       CHECK_EQUAL(t1.get(), t2.get());
     }
 
+    //*************************************************************************
+    TEST(test_get_constexpr)
+    {
+      class type1_t_tag;
+      typedef etl::type_def<type1_t_tag, uint32_t> type1_t;
+
+      class type2_t_tag;
+      typedef etl::type_def<type2_t_tag, uint32_t> type2_t;
+
+      constexpr type1_t t1(1);
+      constexpr type2_t t2(1);
+
+      CHECK_EQUAL(t1.get(), t2.get());
+    }
+
     //*************************************************************************
     TEST(test_operators)
     {
@@ -141,5 +191,73 @@ namespace
       CHECK(!(t1 >= t2));
       CHECK(t2 >= t4);
     }
+
+    //*************************************************************************
+    TEST(test_comparisons_constexpr)
+    {
+      class __type_t__;
+      typedef etl::type_def<__type_t__, uint32_t> type_t;
+
+      constexpr type_t t1(1);
+      constexpr type_t t2(2);
+
+      constexpr bool eq   = t1 == t1;
+      constexpr bool neq  = t1 == t2;
+      constexpr bool lt   = t1  < t2;
+      constexpr bool nlt  = t2  < t1;
+      constexpr bool lte  = t1 <= t2;
+      constexpr bool nlte = t2 <= t1;
+      constexpr bool gt   = t1  > t2;
+      constexpr bool ngt  = t2  > t1;
+      constexpr bool gte  = t1 >= t2;
+      constexpr bool ngte = t2 >= t1;
+
+      CHECK_TRUE(eq);
+      CHECK_FALSE(neq);
+      CHECK_TRUE(lt);
+      CHECK_FALSE(nlt);
+      CHECK_TRUE(lte);
+      CHECK_FALSE(nlte);
+      CHECK_FALSE(gt);
+      CHECK_TRUE(ngt);
+      CHECK_FALSE(gte);
+      CHECK_TRUE(ngte);
+    }
+
+#if ETL_USING_CPP14
+    //*************************************************************************
+    ETL_TYPEDEF(int32_t, arithmetic_type_t);
+
+    constexpr arithmetic_type_t CreatePlus()
+    {
+      arithmetic_type_t value = 0;
+
+      ++value;
+      value++;
+      value += 1;
+
+      return value;
+    }
+
+    constexpr arithmetic_type_t CreateMinus()
+    {
+      arithmetic_type_t value = 0;
+
+      --value;
+      value--;
+      value -= 1;
+
+      return value;
+    }
+    
+    TEST(test_arithmetic_constexpr)
+    {
+      constexpr arithmetic_type_t value_plus  = CreatePlus();
+      constexpr arithmetic_type_t value_minus = CreateMinus();
+
+      CHECK_EQUAL(3,  value_plus.get());
+      CHECK_EQUAL(-3, value_minus.get());
+    }
+#endif
   };
 }
diff --git a/test/test_type_traits.cpp b/test/test_type_traits.cpp
index dec68f39..af5feaca 100644
--- a/test/test_type_traits.cpp
+++ b/test/test_type_traits.cpp
@@ -45,7 +45,7 @@ namespace etl
 namespace
 {
   // A class to test non-fundamental types.
-  struct Test
+  struct Object
   {
     int a;
   };
@@ -111,6 +111,17 @@ namespace
     MoveableCopyable(const MoveableCopyable&) {}
     MoveableCopyable& operator =(const MoveableCopyable&) { return *this; }
   };
+
+  //*********************************************
+  struct NotDefaultConstructible
+  {
+    NotDefaultConstructible() = delete;
+    NotDefaultConstructible(const NotDefaultConstructible&) noexcept {}
+    NotDefaultConstructible& operator =(const NotDefaultConstructible&) noexcept { return *this; }
+
+    NotDefaultConstructible(NotDefaultConstructible&&) = delete;
+    NotDefaultConstructible& operator =(NotDefaultConstructible&) = delete;
+  };
 }
 
 // Definitions for when the STL and compiler built-ins are not available.
@@ -671,7 +682,7 @@ namespace
     //*************************************************************************
     TEST(test_alignment_of)
     {
-      struct Test
+      struct Object
       {
         int   a;
         char  b;
@@ -690,7 +701,7 @@ namespace
       CHECK(std::alignment_of<unsigned long long>::value == etl::alignment_of<unsigned long long>::value);
       CHECK(std::alignment_of<float>::value              == etl::alignment_of<float>::value);
       CHECK(std::alignment_of<double>::value             == etl::alignment_of<double>::value);
-      CHECK(std::alignment_of<Test>::value               == etl::alignment_of<Test>::value);
+      CHECK(std::alignment_of<Object>::value             == etl::alignment_of<Object>::value);
     }
 
     //*************************************************************************
@@ -1137,10 +1148,28 @@ namespace
     CHECK((etl::is_constructible_v<Copyable>) == (std::is_constructible_v<Copyable>));
     CHECK((etl::is_constructible_v<Moveable>) == (std::is_constructible_v<Moveable>));
     CHECK((etl::is_constructible_v<MoveableCopyable>) == (std::is_constructible_v<MoveableCopyable>));
+    CHECK((etl::is_constructible_v<NotDefaultConstructible>) == (std::is_constructible_v<NotDefaultConstructible>));
 #else
     CHECK((etl::is_constructible<Copyable>::value) == (std::is_constructible<Copyable>::value));
     CHECK((etl::is_constructible<Moveable>::value) == (std::is_constructible<Moveable>::value));
     CHECK((etl::is_constructible<MoveableCopyable>::value) == (std::is_constructible<MoveableCopyable>::value));
+    CHECK((etl::is_constructible<NotDefaultConstructible>::value) == (std::is_constructible<NotDefaultConstructible>::value));
+#endif
+  }
+
+  //*************************************************************************
+  TEST(test_is_default_constructible)
+  {
+#if ETL_USING_CPP17
+    CHECK((etl::is_default_constructible_v<Copyable>) == (std::is_default_constructible_v<Copyable>));
+    CHECK((etl::is_default_constructible_v<Moveable>) == (std::is_default_constructible_v<Moveable>));
+    CHECK((etl::is_default_constructible_v<MoveableCopyable>) == (std::is_default_constructible_v<MoveableCopyable>));
+    CHECK((etl::is_default_constructible_v<NotDefaultConstructible>) == (std::is_default_constructible_v<NotDefaultConstructible>));
+#else
+    CHECK((etl::is_default_constructible<Copyable>::value) == (std::is_default_constructible<Copyable>::value));
+    CHECK((etl::is_default_constructible<Moveable>::value) == (std::is_default_constructible<Moveable>::value));
+    CHECK((etl::is_default_constructible<MoveableCopyable>::value) == (std::is_default_constructible<MoveableCopyable>::value));
+    CHECK((etl::is_default_constructible<NotDefaultConstructible>::value) == (std::is_default_constructible<NotDefaultConstructible>::value));
 #endif
   }
 
diff --git a/test/test_unordered_map.cpp b/test/test_unordered_map.cpp
index 45a28397..93f66457 100644
--- a/test/test_unordered_map.cpp
+++ b/test/test_unordered_map.cpp
@@ -1193,5 +1193,19 @@ namespace
       using Map = etl::unordered_map<int, int, 1, 1>;
       CHECK((!std::is_same<typename Map::const_iterator::value_type, typename Map::iterator::value_type>::value));
     }
+
+    //*************************************************************************
+    TEST(test_iterator_value_types_bug_803)
+    {
+      using Map1 = etl::unordered_map<std::string, NDC, SIZE, 5>;
+      using Map2 = etl::unordered_map<std::string, NDC, 2 * SIZE, 10>;
+      
+      Map1 map1(initial_data.begin(), initial_data.end());
+      Map2 map2a(initial_data.begin(), initial_data.end());
+      Map2 map2b(different_data.begin(), different_data.end());
+      
+      CHECK_TRUE(map1 == map2a);
+      CHECK_FALSE(map1 == map2b);
+    }
   };
 }
diff --git a/test/test_unordered_multimap.cpp b/test/test_unordered_multimap.cpp
index 8bd86523..38d198bf 100644
--- a/test/test_unordered_multimap.cpp
+++ b/test/test_unordered_multimap.cpp
@@ -1030,6 +1030,7 @@ namespace
       CHECK((!std::is_same<typename Map::const_iterator::value_type, typename Map::iterator::value_type>::value));
     }
 
+    //*************************************************************************
     TEST(test_parameterized_eq)
     {
       constexpr std::size_t MODULO = 4;
@@ -1053,5 +1054,19 @@ namespace
         CHECK_EQUAL(std::distance(range.first, range.second), 3);
       }
     }
+
+    //*************************************************************************
+    TEST(test_iterator_value_types_bug_803)
+    {
+      using Map1 = etl::unordered_multimap<std::string, NDC, SIZE, 5>;
+      using Map2 = etl::unordered_multimap<std::string, NDC, 2 * SIZE, 10>;
+
+      Map1 map1(initial_data.begin(), initial_data.end());
+      Map2 map2a(initial_data.begin(), initial_data.end());
+      Map2 map2b(different_data.begin(), different_data.end());
+
+      CHECK_TRUE(map1 == map2a);
+      CHECK_FALSE(map1 == map2b);
+    }
   };
 }
diff --git a/test/test_unordered_multiset.cpp b/test/test_unordered_multiset.cpp
index c891730a..8337a015 100644
--- a/test/test_unordered_multiset.cpp
+++ b/test/test_unordered_multiset.cpp
@@ -929,5 +929,19 @@ namespace
         CHECK_EQUAL(std::distance(range.first, range.second), 3);
       }
     }
+
+    //*************************************************************************
+    TEST(test_iterator_value_types_bug_803)
+    {
+      using Set1 = etl::unordered_multiset<NDC, SIZE, 5>;
+      using Set2 = etl::unordered_multiset<NDC, 2 * SIZE, 10>;
+
+      Set1 set1(initial_data.begin(), initial_data.end());
+      Set2 set2a(initial_data.begin(), initial_data.end());
+      Set2 set2b(different_data.begin(), different_data.end());
+
+      CHECK_TRUE(set1 == set2a);
+      CHECK_FALSE(set1 == set2b);
+    }
   };
 }
diff --git a/test/test_unordered_set.cpp b/test/test_unordered_set.cpp
index 8ef20ad3..7a4210cc 100644
--- a/test/test_unordered_set.cpp
+++ b/test/test_unordered_set.cpp
@@ -895,5 +895,19 @@ namespace
       using Set = etl::unordered_set<int, 1, 1>;
       CHECK((!std::is_same<typename Set::const_iterator::value_type, typename Set::iterator::value_type>::value));
     }
+
+    //*************************************************************************
+    TEST(test_iterator_value_types_bug_803)
+    {
+      using Set1 = etl::unordered_set<NDC, SIZE, 5>;
+      using Set2 = etl::unordered_set<NDC, 2 * SIZE, 10>;
+
+      Set1 set1(initial_data.begin(), initial_data.end());
+      Set2 set2a(initial_data.begin(), initial_data.end());
+      Set2 set2b(different_data.begin(), different_data.end());
+
+      CHECK_TRUE(set1 == set2a);
+      CHECK_FALSE(set1 == set2b);
+    }
   };
 }
diff --git a/test/test_utility.cpp b/test/test_utility.cpp
index cb386b2f..a1f28e95 100644
--- a/test/test_utility.cpp
+++ b/test/test_utility.cpp
@@ -33,6 +33,7 @@ SOFTWARE.
 #include <map>
 #include <vector>
 #include <algorithm>
+#include <type_traits>
 
 #include "data.h"
 
diff --git a/test/test_variant_legacy.cpp b/test/test_variant_legacy.cpp
index afd36fa7..4e53473b 100644
--- a/test/test_variant_legacy.cpp
+++ b/test/test_variant_legacy.cpp
@@ -912,7 +912,7 @@ namespace
     {
       test_variant_3 variant;
       variant = int8_t{};
-      // c++98 should generate a const ref of dispatchern.
+      // c++98 should generate a const ref of dispatcher.
       int16_t type = etl::legacy::visit<int16_t>(variant_test_visit_dispatcher{}, variant);
       CHECK_EQUAL(1, type);
       test_variant_3 const& variant_const = variant;
diff --git a/test/test_variant_variadic.cpp b/test/test_variant_variadic.cpp
index 34e9178c..a9a7331e 100644
--- a/test/test_variant_variadic.cpp
+++ b/test/test_variant_variadic.cpp
@@ -44,6 +44,32 @@ SOFTWARE.
   #include <variant>
 #endif
 
+#if ETL_USING_CPP20
+  #include <compare>
+
+  std::ostream& operator <<(std::ostream& os, const std::strong_ordering& ordering)
+  {
+    if (ordering == std::strong_ordering::equal)
+    {
+      os << "std::strong_ordering::equal";
+    }
+    else if (ordering == std::strong_ordering::equivalent)
+    {
+      os << "std::strong_ordering::equivalent";
+    }
+    else if (ordering == std::strong_ordering::greater)
+    {
+      os << "std::strong_ordering::greater";
+    }
+    else if (ordering == std::strong_ordering::less)
+    {
+      os << "std::strong_ordering::less";
+    }
+
+    return os;
+  }
+#endif
+
 #include "etl/private/diagnostic_useless_cast_push.h"
 
 namespace
@@ -296,6 +322,10 @@ namespace
   };
 }
 
+// Moved from the top of the file otherwise clang has issues with
+// operator<< for std::strong_ordering.
+//#include "unit_test_framework.h"
+
 // Definitions for when the STL and compiler built-ins are not available.
 #if ETL_NOT_USING_STL && !defined(ETL_USE_TYPE_TRAITS_BUILTINS)
 
@@ -420,15 +450,15 @@ namespace
 
       test_variant_etl_3 variant_etl;
 
-      CHECK(etl::holds_alternative<char>(variant_etl));
+      CHECK(!etl::holds_alternative<char>(variant_etl));
       CHECK(!etl::holds_alternative<int>(variant_etl));
       CHECK(!etl::holds_alternative<std::string>(variant_etl));
 
-      CHECK(etl::holds_alternative<0U>(variant_etl));
+      CHECK(!etl::holds_alternative<0U>(variant_etl));
       CHECK(!etl::holds_alternative<1U>(variant_etl));
       CHECK(!etl::holds_alternative<2U>(variant_etl));
 
-      CHECK(etl::holds_alternative(0U, variant_etl));
+      CHECK(!etl::holds_alternative(0U, variant_etl));
       CHECK(!etl::holds_alternative(1U, variant_etl));
       CHECK(!etl::holds_alternative(2U, variant_etl));
       CHECK(!etl::holds_alternative(99U, variant_etl));
@@ -1830,7 +1860,7 @@ namespace
     //*************************************************************************
     TEST(test_variant_visit_void)
     {
-      etl::variant<int8_t, uint8_t> variant1;
+      etl::variant<int8_t, uint8_t> variant1 = int8_t{};
 
       bool       variant_was_signed{};
       auto const f = [&variant_was_signed](auto v)
@@ -1857,7 +1887,7 @@ namespace
 
       std::string result = "?";
 
-      etl::variant<TypeA, TypeB, TypeC, TypeD> package;
+      etl::variant<TypeA, TypeB, TypeC, TypeD> package = TypeA{};
 
       etl::visit(etl::overload
         {
@@ -1918,6 +1948,128 @@ namespace
       CHECK_EQUAL(std::string("TypeD"), result);
     }
 #endif
+
+#if ETL_USING_CPP14
+    //*************************************************************************
+    TEST(test_variant_comparisons)
+    {
+      using Variant = etl::variant<char, int, std::string>;
+    
+      Variant v_empty1;
+      Variant v_empty2;
+
+      Variant v_char_a('A');
+      Variant v_char_b('B');
+
+      Variant v_int_1(1);
+      Variant v_int_2(2);
+
+      Variant v_hello(std::string("hello"));
+      Variant v_world(std::string("world"));
+
+      CHECK_TRUE(v_empty1 == v_empty2);
+      CHECK_TRUE(v_empty1 < v_char_a);
+      CHECK_FALSE(v_char_a < v_empty1);
+
+      CHECK_TRUE(v_char_a == v_char_a);
+      CHECK_TRUE(v_char_a < v_char_b);
+      CHECK_FALSE(v_char_b < v_char_a);
+      CHECK_FALSE(v_char_a > v_char_b);
+      CHECK_TRUE(v_char_b > v_char_a);
+      CHECK_TRUE(v_char_a <= v_char_b);
+      CHECK_FALSE(v_char_b <= v_char_a);
+      CHECK_FALSE(v_char_a >= v_char_b);
+      CHECK_TRUE(v_char_b >= v_char_a);
+      CHECK_TRUE(v_char_a <= v_char_a);
+      CHECK_TRUE(v_char_a >= v_char_a);
+
+      CHECK_TRUE(v_int_1 == v_int_1);
+      CHECK_TRUE(v_int_1 < v_int_2);
+      CHECK_FALSE(v_int_2 < v_int_1);
+      CHECK_FALSE(v_int_1 > v_int_2);
+      CHECK_TRUE(v_int_2 > v_int_1);
+      CHECK_TRUE(v_int_1 <= v_int_2);
+      CHECK_FALSE(v_int_2 <= v_int_1);
+      CHECK_FALSE(v_int_1 >= v_int_2);
+      CHECK_TRUE(v_int_2 >= v_int_1);
+      CHECK_TRUE(v_int_1 <= v_int_1);
+      CHECK_TRUE(v_int_1 >= v_int_1);
+
+      CHECK_TRUE(v_hello == v_hello);
+      CHECK_TRUE(v_hello < v_world);
+      CHECK_FALSE(v_world < v_hello);
+      CHECK_FALSE(v_hello > v_world);
+      CHECK_TRUE(v_world > v_hello);
+      CHECK_TRUE(v_hello <= v_world);
+      CHECK_FALSE(v_world <= v_hello);
+      CHECK_FALSE(v_hello >= v_world);
+      CHECK_TRUE(v_world >= v_hello);
+      CHECK_TRUE(v_hello <= v_hello);
+      CHECK_TRUE(v_hello >= v_hello);
+    }
+#endif
+
+#if ETL_USING_CPP20 && ETL_USING_STL && !(defined(ETL_DEVELOPMENT_OS_APPLE) && defined(ETL_COMPILER_CLANG))
+    //*************************************************************************
+    TEST(test_variant_spaceship_operator)
+    {
+      using Variant = etl::variant<char, int>;
+
+      Variant v_empty1;
+      Variant v_empty2;
+
+      Variant v_char_a('A');
+      Variant v_char_b('B');
+
+      Variant v_int_1(1);
+      Variant v_int_2(2);
+
+      CHECK(std::strong_ordering::equal   == v_empty1 <=> v_empty2);
+      CHECK(std::strong_ordering::less    == v_empty1 <=> v_char_a);
+      CHECK(std::strong_ordering::greater == v_char_a <=> v_empty1);
+
+      CHECK(std::strong_ordering::equal   == v_char_a <=> v_char_a);
+      CHECK(std::strong_ordering::less    == v_char_a <=> v_char_b);
+      CHECK(std::strong_ordering::greater == v_char_b <=> v_char_a);
+
+      CHECK(std::strong_ordering::equal   == v_int_1 <=> v_int_1);
+      CHECK(std::strong_ordering::less    == v_int_1 <=> v_int_2);
+      CHECK(std::strong_ordering::greater == v_int_2 <=> v_int_1);
+
+      CHECK(std::strong_ordering::less    == v_char_a <=> v_int_1);
+      CHECK(std::strong_ordering::greater == v_int_2  <=> v_char_a);
+    }
+#endif
+
+    //*************************************************************************
+    TEST(test_variant_three_way_compare_using_etl_compare_cmp)
+    {
+      using Variant = etl::variant<char, int>;
+
+      Variant v_empty1;
+      Variant v_empty2;
+
+      Variant v_char_a('A');
+      Variant v_char_b('B');
+
+      Variant v_int_1(1);
+      Variant v_int_2(2);
+
+      using Compare = etl::compare<Variant>;
+
+      CHECK_EQUAL(Compare::Equal,   (Compare::cmp(v_empty1, v_empty2)));
+      
+      CHECK_EQUAL(Compare::Equal,   (Compare::cmp(v_char_a, v_char_a)));
+      CHECK_EQUAL(Compare::Less,    (Compare::cmp(v_char_a, v_char_b)));
+      CHECK_EQUAL(Compare::Greater, (Compare::cmp(v_char_b, v_char_a)));
+      
+      CHECK_EQUAL(Compare::Equal,   (Compare::cmp(v_int_1,  v_int_1)));
+      CHECK_EQUAL(Compare::Less,    (Compare::cmp(v_int_1,  v_int_2)));
+      CHECK_EQUAL(Compare::Greater, (Compare::cmp(v_int_2,  v_int_1)));
+
+      CHECK_EQUAL(Compare::Less,    (Compare::cmp(v_char_a, v_int_1)));
+      CHECK_EQUAL(Compare::Greater, (Compare::cmp(v_int_1,  v_char_a)));
+    }
   };
 }
 
diff --git a/test/test_vector.cpp b/test/test_vector.cpp
index e8e4f1fa..ce85bcfe 100644
--- a/test/test_vector.cpp
+++ b/test/test_vector.cpp
@@ -1365,7 +1365,7 @@ namespace
 
         }
 
-        S(int i): i(i){}
+        S(int i_): i(i_){}
 
         int i;
       };
@@ -1398,7 +1398,7 @@ namespace
 
         }
 
-        S(int i): i(i){}
+        S(int i_): i(i_){}
 
         int i;
       };
diff --git a/test/test_vector_external_buffer.cpp b/test/test_vector_external_buffer.cpp
index e1baf1cf..773e68ea 100644
--- a/test/test_vector_external_buffer.cpp
+++ b/test/test_vector_external_buffer.cpp
@@ -1199,7 +1199,7 @@ namespace
 
         }
 
-        S(int i): i(i){}
+        S(int i_): i(i_){}
 
         int i;
       };
@@ -1235,7 +1235,7 @@ namespace
 
         }
 
-        S(int i): i(i){}
+        S(int i_): i(i_){}
 
         int i;
       };
diff --git a/test/test_vector_non_trivial.cpp b/test/test_vector_non_trivial.cpp
index 58ae569d..0acb1a22 100644
--- a/test/test_vector_non_trivial.cpp
+++ b/test/test_vector_non_trivial.cpp
@@ -213,7 +213,6 @@ namespace
     //*************************************************************************
     TEST(test_move_constructor)
     {
-      const size_t SIZE = 10U;
       typedef etl::vector<std::unique_ptr<uint32_t>, SIZE> Data;
 
       std::unique_ptr<uint32_t> p1(new uint32_t(1U));
@@ -256,7 +255,6 @@ namespace
     //*************************************************************************
     TEST(test_move_assignment)
     {
-      const size_t SIZE = 10U;
       typedef etl::vector<std::unique_ptr<uint32_t>, SIZE> Data;
 
       std::unique_ptr<uint32_t> p1(new uint32_t(1U));
@@ -303,7 +301,6 @@ namespace
     //*************************************************************************
     TEST(test_move_assignment_interface)
     {
-      const size_t SIZE = 10U;
       typedef etl::vector<std::unique_ptr<uint32_t>, SIZE> Data;
       typedef etl::ivector<std::unique_ptr<uint32_t>> IData;
 
diff --git a/test/vs2022/cpp.hint b/test/vs2022/cpp.hint
index 1412ab0f..6aeae32e 100644
--- a/test/vs2022/cpp.hint
+++ b/test/vs2022/cpp.hint
@@ -3,6 +3,7 @@
 // For more information see https://go.microsoft.com/fwlink/?linkid=865984
 #define ETL_CONSTANT
 #define ETL_CONSTEXPR
+#define ETL_CONSTEXPR11
 #define ETL_CONSTEXPR14
 #define ETL_CONSTEXPR17
 #define ETL_IF_CONSTEXPR
@@ -22,6 +23,18 @@
 #define ETL_CPP11_SUPPORTED
 #define ETL_CPP14_SUPPORTED
 #define ETL_CPP17_SUPPORTED
+#define ETL_CPP17_SUPPORTED
+#define ETL_USING_CPP11
+#define ETL_USING_CPP14
+#define ETL_USING_CPP17
+#define ETL_USING_CPP20
 #define ETL_ASSERT
 #define ETL_NULLPTR
 #define ETL_USING_STLPORT
+#define CHECK
+#define CHECK_FALSE
+#define CHECK_TRUE
+#define CHECK_EQUAL
+#define CHECK_ARRAY_EQUAL
+#define CHECK_CLOSE
+#define CHECK_THROW
diff --git a/test/vs2022/etl.sln b/test/vs2022/etl.sln
index 48c644d9..3b5f836e 100644
--- a/test/vs2022/etl.sln
+++ b/test/vs2022/etl.sln
@@ -25,6 +25,8 @@ Global
 		Debug MSVC C++20 - No virtual messages|x64 = Debug MSVC C++20 - No virtual messages|x64
 		Debug MSVC C++20|Win32 = Debug MSVC C++20|Win32
 		Debug MSVC C++20|x64 = Debug MSVC C++20|x64
+		Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32 = Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32
+		Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64 = Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64
 		Release MSVC C++20 - No STL - Optimised -O2|Win32 = Release MSVC C++20 - No STL - Optimised -O2|Win32
 		Release MSVC C++20 - No STL - Optimised -O2|x64 = Release MSVC C++20 - No STL - Optimised -O2|x64
 		Release MSVC C++20 - Optimised O2|Win32 = Release MSVC C++20 - Optimised O2|Win32
@@ -67,6 +69,10 @@ Global
 		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC C++20|Win32.Build.0 = Debug MSVC C++20|Win32
 		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC C++20|x64.ActiveCfg = Debug MSVC C++20|x64
 		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug MSVC C++20|x64.Build.0 = Debug MSVC C++20|x64
+		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32.ActiveCfg = Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32
+		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32.Build.0 = Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32
+		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64.ActiveCfg = Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64
+		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64.Build.0 = Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64
 		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release MSVC C++20 - No STL - Optimised -O2|Win32.ActiveCfg = Release MSVC C++20 - No STL - Optimised -O2|Win32
 		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release MSVC C++20 - No STL - Optimised -O2|Win32.Build.0 = Release MSVC C++20 - No STL - Optimised -O2|Win32
 		{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release MSVC C++20 - No STL - Optimised -O2|x64.ActiveCfg = Release MSVC C++20 - No STL - Optimised -O2|x64
diff --git a/test/vs2022/etl.vcxproj b/test/vs2022/etl.vcxproj
index 4c18142c..c95a0d70 100644
--- a/test/vs2022/etl.vcxproj
+++ b/test/vs2022/etl.vcxproj
@@ -81,6 +81,14 @@
       <Configuration>Debug MSVC C++20</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
+    <ProjectConfiguration Include="Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32">
+      <Configuration>Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64">
+      <Configuration>Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
     <ProjectConfiguration Include="Release MSVC C++20 - No STL - Optimised -O2|Win32">
       <Configuration>Release MSVC C++20 - No STL - Optimised -O2</Configuration>
       <Platform>Win32</Platform>
@@ -160,7 +168,7 @@
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
-    <EnableASAN>false</EnableASAN>
+    <EnableASAN>true</EnableASAN>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
@@ -197,6 +205,13 @@
     <CharacterSet>Unicode</CharacterSet>
     <EnableASAN>false</EnableASAN>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>false</EnableASAN>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
@@ -420,6 +435,12 @@
     <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
@@ -638,6 +659,9 @@
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
@@ -743,6 +767,9 @@
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
@@ -839,17 +866,17 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - Force C++03|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No virtual messages|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
@@ -859,37 +886,42 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++ 20 - No Tests|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
+    <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
+    <IntDir>$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
@@ -935,7 +967,7 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14 - No STL|Win32'">
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
@@ -1061,6 +1093,10 @@
     <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">
     <LinkIncremental>true</LinkIncremental>
     <PostBuildEventUseInBuild>true</PostBuildEventUseInBuild>
@@ -1231,7 +1267,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1257,7 +1293,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_FORCE_TEST_CPP03_IMPLEMENTATION;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1283,7 +1319,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_MESSAGES_ARE_NOT_VIRTUAL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1309,7 +1345,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_IMESSAGE_IS_NON_VIRTUAL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1335,7 +1371,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1360,7 +1396,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>MaxSpeed</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1385,7 +1421,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1409,7 +1445,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1433,7 +1469,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_NO_STL;ETL_FORCE_STD_INITIALIZER_LIST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1457,7 +1493,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_NO_STL;ETL_FORCE_STD_INITIALIZER_LIST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1481,7 +1517,32 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_NO_STL;ETL_FORCE_STD_INITIALIZER_LIST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
+      <UndefinePreprocessorDefinitions>
+      </UndefinePreprocessorDefinitions>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <AdditionalOptions>/Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <PostBuildEvent>
+      <Command>"$(OutDir)\etl.exe"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>MaxSpeed</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_NO_STL;ETL_FORCE_STD_INITIALIZER_LIST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -1691,7 +1752,7 @@
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
-      <WarningLevel>Level2</WarningLevel>
+      <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;_SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING;ETL_NO_STL;ETL_FORCE_STD_INITIALIZER_LIST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>./;../../../unittest-cpp/;../../include;../../test</AdditionalIncludeDirectories>
@@ -2324,6 +2385,27 @@
       <Command>$(OutDir)\etl.exe</Command>
     </PostBuildEvent>
   </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../unittest-cpp/UnitTest++/;../../include/etl;../../test</AdditionalIncludeDirectories>
+      <UndefinePreprocessorDefinitions>
+      </UndefinePreprocessorDefinitions>
+      <MultiProcessorCompilation>false</MultiProcessorCompilation>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <PostBuildEvent>
+      <Command>$(OutDir)\etl.exe</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">
     <ClCompile>
       <PrecompiledHeader>
@@ -2994,6 +3076,8 @@
     <ClInclude Include="..\..\include\etl\crc8_ebu.h" />
     <ClInclude Include="..\..\include\etl\crc8_icode.h" />
     <ClInclude Include="..\..\include\etl\crc8_itu.h" />
+    <ClInclude Include="..\..\include\etl\crc8_j1850.h" />
+    <ClInclude Include="..\..\include\etl\crc8_j1850_zero.h" />
     <ClInclude Include="..\..\include\etl\crc8_maxim.h" />
     <ClInclude Include="..\..\include\etl\crc8_rohc.h" />
     <ClInclude Include="..\..\include\etl\crc8_wcdma.h" />
@@ -3277,6 +3361,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC - No STL -O2|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -3314,6 +3399,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC - No STL -O2|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -3351,6 +3437,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -3388,6 +3475,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC - No STL -O2|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -3469,6 +3557,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC - No STL -O2|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -3506,6 +3595,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC - No STL -O2|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -3543,6 +3633,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -3580,6 +3671,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC - No STL -O2|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -3608,6 +3700,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3622,6 +3715,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3636,6 +3730,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3650,6 +3745,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3664,6 +3760,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3678,6 +3775,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3692,6 +3790,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3706,6 +3805,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3720,6 +3820,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3734,6 +3835,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3748,6 +3850,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3762,6 +3865,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3776,6 +3880,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3790,6 +3895,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3804,6 +3910,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3818,6 +3925,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3832,6 +3940,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3846,6 +3955,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3860,6 +3970,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3874,6 +3985,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3888,6 +4000,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3902,6 +4015,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3916,6 +4030,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3930,6 +4045,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3944,6 +4060,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3958,6 +4075,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3972,6 +4090,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -3986,6 +4105,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4000,6 +4120,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4014,6 +4135,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4028,6 +4150,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4042,6 +4165,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4056,6 +4180,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4070,6 +4195,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4084,6 +4210,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4098,6 +4225,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4112,6 +4240,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4126,6 +4255,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4140,6 +4270,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4154,6 +4285,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4168,6 +4300,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4182,6 +4315,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4196,6 +4330,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4210,6 +4345,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4224,6 +4360,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4238,6 +4375,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4252,6 +4390,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4266,6 +4405,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4280,6 +4420,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4294,6 +4435,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4308,6 +4450,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4322,6 +4465,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4336,6 +4480,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4350,6 +4495,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4364,6 +4510,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4378,6 +4525,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4392,6 +4540,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4406,6 +4555,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4420,6 +4570,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4434,6 +4585,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4448,6 +4600,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4462,6 +4615,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4476,6 +4630,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4490,6 +4645,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4504,6 +4660,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4518,6 +4675,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4532,6 +4690,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4546,6 +4705,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4560,6 +4720,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4574,6 +4735,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4588,6 +4750,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4602,6 +4765,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4616,6 +4780,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4630,6 +4795,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4644,6 +4810,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4658,6 +4825,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4672,6 +4840,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4686,6 +4855,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4700,6 +4870,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4714,6 +4885,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4728,6 +4900,37 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No virtual messages|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14 - No STL|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - Force C++03|Win32'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\syntax_check\crc8_j1850.h.t.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No virtual imessage|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++ 20 - No Tests|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No virtual messages|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14 - No STL|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - Force C++03|Win32'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\syntax_check\crc8_j1850_zero.h.t.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No virtual imessage|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++ 20 - No Tests|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4742,6 +4945,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4756,6 +4960,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4770,6 +4975,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4784,6 +4990,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4798,6 +5005,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4812,6 +5020,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4826,6 +5035,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4840,6 +5050,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4854,6 +5065,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4868,6 +5080,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4882,6 +5095,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4896,6 +5110,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4910,6 +5125,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4924,6 +5140,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4938,6 +5155,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4952,6 +5170,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4966,6 +5185,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4980,6 +5200,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -4994,6 +5215,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5008,6 +5230,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5022,6 +5245,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5036,6 +5260,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5050,6 +5275,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5064,6 +5290,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5078,6 +5305,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5092,6 +5320,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5106,6 +5335,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5120,6 +5350,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5134,6 +5365,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5148,6 +5380,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5162,6 +5395,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5176,6 +5410,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5190,6 +5425,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5204,6 +5440,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5218,6 +5455,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5232,6 +5470,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5246,6 +5485,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5260,6 +5500,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5274,6 +5515,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5288,6 +5530,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5302,6 +5545,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5316,6 +5560,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5330,6 +5575,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5344,6 +5590,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5358,6 +5605,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5372,6 +5620,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5386,6 +5635,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5400,6 +5650,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5414,6 +5665,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5428,6 +5680,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5442,6 +5695,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5456,6 +5710,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5470,6 +5725,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5484,6 +5740,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5498,6 +5755,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5512,6 +5770,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5526,6 +5785,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5540,6 +5800,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5554,6 +5815,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5568,6 +5830,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5582,6 +5845,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5596,6 +5860,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5610,6 +5875,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5624,6 +5890,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5638,6 +5905,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5652,6 +5920,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5666,6 +5935,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5680,6 +5950,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5694,6 +5965,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5708,6 +5980,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5722,6 +5995,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5736,6 +6010,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5750,6 +6025,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5764,6 +6040,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5778,6 +6055,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5792,6 +6070,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5806,6 +6085,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5820,6 +6100,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5834,6 +6115,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5848,6 +6130,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5862,6 +6145,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5876,6 +6160,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5890,6 +6175,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5904,6 +6190,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5918,6 +6205,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5932,6 +6220,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5946,6 +6235,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5960,6 +6250,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5974,6 +6265,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -5988,6 +6280,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6002,6 +6295,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6016,6 +6310,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6030,6 +6325,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6044,6 +6340,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6058,6 +6355,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6072,6 +6370,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6086,6 +6385,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6100,6 +6400,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6114,6 +6415,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6128,6 +6430,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6142,6 +6445,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6156,6 +6460,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6170,6 +6475,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6184,6 +6490,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6198,6 +6505,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6212,6 +6520,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6226,6 +6535,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6240,6 +6550,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6254,6 +6565,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6268,6 +6580,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6282,6 +6595,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6296,6 +6610,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6310,6 +6625,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6324,6 +6640,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6338,6 +6655,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6352,6 +6670,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6366,6 +6685,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6380,6 +6700,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6394,6 +6715,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6408,6 +6730,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6422,6 +6745,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6436,6 +6760,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6450,6 +6775,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6464,6 +6790,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6478,6 +6805,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6492,6 +6820,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6506,6 +6835,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6520,6 +6850,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6534,6 +6865,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6548,6 +6880,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6562,6 +6895,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6576,6 +6910,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6590,6 +6925,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6604,6 +6940,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6618,6 +6955,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6632,6 +6970,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6646,6 +6985,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6660,6 +7000,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6674,6 +7015,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6688,6 +7030,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6702,6 +7045,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6716,6 +7060,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6730,6 +7075,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6744,6 +7090,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6758,6 +7105,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6772,6 +7120,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6786,6 +7135,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6800,6 +7150,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6814,6 +7165,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6828,6 +7180,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6842,6 +7195,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6856,6 +7210,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6870,6 +7225,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6884,6 +7240,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6898,6 +7255,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6912,6 +7270,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6926,6 +7285,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6940,6 +7300,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6954,6 +7315,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6968,6 +7330,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6982,6 +7345,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -6996,6 +7360,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7010,6 +7375,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7024,6 +7390,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7038,6 +7405,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7052,6 +7420,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7066,6 +7435,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7080,6 +7450,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7094,6 +7465,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7108,6 +7480,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7122,6 +7495,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7136,6 +7510,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7150,6 +7525,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7164,6 +7540,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7178,6 +7555,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7192,6 +7570,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7206,6 +7585,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7220,6 +7600,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7234,6 +7615,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7248,6 +7630,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7262,6 +7645,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7276,6 +7660,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
@@ -7288,6 +7673,7 @@
     <ClCompile Include="..\test_atomic.cpp" />
     <ClCompile Include="..\test_base64.cpp" />
     <ClCompile Include="..\test_bit.cpp" />
+    <ClCompile Include="..\test_bitset_new_comparisons.cpp" />
     <ClCompile Include="..\test_bitset_new_default_element_type.cpp" />
     <ClCompile Include="..\test_bitset_new_explicit_single_element_type.cpp" />
     <ClCompile Include="..\test_bitset_new_ext_default_element_type.cpp" />
@@ -7354,6 +7740,8 @@
     <ClCompile Include="..\test_crc8_ebu.cpp" />
     <ClCompile Include="..\test_crc8_icode.cpp" />
     <ClCompile Include="..\test_crc8_itu.cpp" />
+    <ClCompile Include="..\test_crc8_j1850.cpp" />
+    <ClCompile Include="..\test_crc8_j1850_zero.cpp" />
     <ClCompile Include="..\test_crc8_maxim.cpp" />
     <ClCompile Include="..\test_crc8_rohc.cpp" />
     <ClCompile Include="..\test_crc8_wcdma.cpp" />
@@ -7363,6 +7751,7 @@
     <ClCompile Include="..\test_macros.cpp" />
     <ClCompile Include="..\test_math.cpp" />
     <ClCompile Include="..\test_math_functions.cpp" />
+    <ClCompile Include="..\test_message.cpp" />
     <ClCompile Include="..\test_message_broker.cpp" />
     <ClCompile Include="..\test_poly_span_dynamic_extent.cpp" />
     <ClCompile Include="..\test_poly_span_fixed_extent.cpp" />
@@ -7436,6 +7825,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|Win32'">false</ExcludedFromBuild>
@@ -7475,6 +7865,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|x64'">false</ExcludedFromBuild>
@@ -7533,6 +7924,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|Win32'">false</ExcludedFromBuild>
@@ -7572,6 +7964,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|x64'">false</ExcludedFromBuild>
@@ -7625,6 +8018,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|Win32'">false</ExcludedFromBuild>
@@ -7664,6 +8058,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|x64'">false</ExcludedFromBuild>
@@ -7707,6 +8102,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|Win32'">false</ExcludedFromBuild>
@@ -7746,6 +8142,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|x64'">false</ExcludedFromBuild>
@@ -7789,6 +8186,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|Win32'">false</ExcludedFromBuild>
@@ -7828,6 +8226,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|x64'">false</ExcludedFromBuild>
@@ -7871,6 +8270,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|Win32'">false</ExcludedFromBuild>
@@ -7910,6 +8310,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|x64'">false</ExcludedFromBuild>
@@ -7958,6 +8359,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|Win32'">false</ExcludedFromBuild>
@@ -7997,6 +8399,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|x64'">false</ExcludedFromBuild>
@@ -8044,6 +8447,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|Win32'">false</ExcludedFromBuild>
@@ -8083,6 +8487,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|x64'">false</ExcludedFromBuild>
@@ -8138,6 +8543,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|Win32'">false</ExcludedFromBuild>
@@ -8177,6 +8583,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force C++03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Force cpp03|x64'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - Small Strings|x64'">false</ExcludedFromBuild>
@@ -8419,6 +8826,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC - No STL -O2|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -8456,6 +8864,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC - No STL -O2|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -8493,6 +8902,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -8530,6 +8940,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC - No STL -O2|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='MSVC Debug - No STL - Appveyor|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC - No STL - Force Constexpr Algorithms|Win32'">true</ExcludedFromBuild>
@@ -8561,6 +8972,7 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++20 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++14|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug MSVC C++17 - No STL|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release MSVC C++20 - Optimised O2|Win32'">true</ExcludedFromBuild>
diff --git a/test/vs2022/etl.vcxproj.filters b/test/vs2022/etl.vcxproj.filters
index 2adfa862..c4825d0a 100644
--- a/test/vs2022/etl.vcxproj.filters
+++ b/test/vs2022/etl.vcxproj.filters
@@ -1389,6 +1389,12 @@
     <ClInclude Include="..\..\include\etl\crc1.h">
       <Filter>ETL\Maths\CRC</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\include\etl\crc8_j1850.h">
+      <Filter>ETL\Maths\CRC</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\etl\crc8_j1850_zero.h">
+      <Filter>ETL\Maths\CRC</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\test_string_char.cpp">
@@ -3245,9 +3251,6 @@
     <ClCompile Include="..\test_math_functions.cpp">
       <Filter>Tests\Maths</Filter>
     </ClCompile>
-    <ClCompile Include="..\syntax_check\math.h.t.cpp">
-      <Filter>Tests\Maths</Filter>
-    </ClCompile>
     <ClCompile Include="..\test_string_u8.cpp">
       <Filter>Tests\Strings</Filter>
     </ClCompile>
@@ -3284,6 +3287,27 @@
     <ClCompile Include="..\test_crc1.cpp">
       <Filter>Tests\CRC</Filter>
     </ClCompile>
+    <ClCompile Include="..\test_bitset_new_comparisons.cpp">
+      <Filter>Tests\Binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\syntax_check\math.h.t.cpp">
+      <Filter>Tests\Syntax Checks\Source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\syntax_check\crc8_j1850.h.t.cpp">
+      <Filter>Tests\Syntax Checks\Source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\syntax_check\crc8_j1850_zero.h.t.cpp">
+      <Filter>Tests\Syntax Checks\Source</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test_crc8_j1850.cpp">
+      <Filter>Tests\CRC</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test_crc8_j1850_zero.cpp">
+      <Filter>Tests\CRC</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test_message.cpp">
+      <Filter>Tests</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\library.properties">
@@ -3340,12 +3364,6 @@
     <None Include="..\..\appveyor.yml">
       <Filter>Resource Files\CI\Appveyor</Filter>
     </None>
-    <None Include="..\..\.github\workflows\clang.yml">
-      <Filter>Resource Files\CI\Github</Filter>
-    </None>
-    <None Include="..\..\.github\workflows\gcc.yml">
-      <Filter>Resource Files\CI\Github</Filter>
-    </None>
     <None Include="..\..\.clang-format">
       <Filter>Resource Files</Filter>
     </None>
@@ -3412,6 +3430,30 @@
     <None Include="..\..\scripts\update_version.py">
       <Filter>Tests\Scripts</Filter>
     </None>
+    <None Include="..\..\.github\workflows\clang-c++11.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\clang-c++14.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\clang-c++17.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\clang-c++20.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++11.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++14.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++17.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
+    <None Include="..\..\.github\workflows\gcc-c++20.yml">
+      <Filter>Resource Files\CI\Github</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Text Include="..\..\support\Release notes.txt">
diff --git a/uml/FSM example.png b/uml/FSM example.png
index 4bc0bfbc..e69de29b 100644
Binary files a/uml/FSM example.png and b/uml/FSM example.png differ
diff --git a/uml/Framework.png b/uml/Framework.png
index 3ff74411..e69de29b 100644
Binary files a/uml/Framework.png and b/uml/Framework.png differ
diff --git a/uml/MessageFramework.png b/uml/MessageFramework.png
index a4b8a424..e69de29b 100644
Binary files a/uml/MessageFramework.png and b/uml/MessageFramework.png differ
diff --git a/uml/source/FSM example.zargo b/uml/source/FSM example.zargo
index 89bfb9b5..e69de29b 100644
Binary files a/uml/source/FSM example.zargo and b/uml/source/FSM example.zargo differ
diff --git a/uml/source/Message Framework.zargo b/uml/source/Message Framework.zargo
index f874146e..e69de29b 100644
Binary files a/uml/source/Message Framework.zargo and b/uml/source/Message Framework.zargo differ