passenger 6.0.20 → 6.0.22

data/src/cxx_supportlib/vendor-modified/boost/container_hash/detail/hash_integral.hpp

@@ -0,0 +1,146 @@
+// Copyright 2021-2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_HASH_DETAIL_HASH_INTEGRAL_HPP
+#define BOOST_HASH_DETAIL_HASH_INTEGRAL_HPP
+
+#include <boost/container_hash/detail/hash_mix.hpp>
+#include <type_traits>
+#include <cstddef>
+#include <climits>
+
+namespace boost
+{
+namespace hash_detail
+{
+
+// libstdc++ doesn't provide support for __int128 in the standard traits
+
+template<class T> struct is_integral: public std::is_integral<T>
+{
+};
+
+template<class T> struct is_unsigned: public std::is_unsigned<T>
+{
+};
+
+template<class T> struct make_unsigned: public std::make_unsigned<T>
+{
+};
+
+#if defined(__SIZEOF_INT128__)
+
+template<> struct is_integral<__int128_t>: public std::true_type
+{
+};
+
+template<> struct is_integral<__uint128_t>: public std::true_type
+{
+};
+
+template<> struct is_unsigned<__int128_t>: public std::false_type
+{
+};
+
+template<> struct is_unsigned<__uint128_t>: public std::true_type
+{
+};
+
+template<> struct make_unsigned<__int128_t>
+{
+    typedef __uint128_t type;
+};
+
+template<> struct make_unsigned<__uint128_t>
+{
+    typedef __uint128_t type;
+};
+
+#endif
+
+template<class T,
+    bool bigger_than_size_t = (sizeof(T) > sizeof(std::size_t)),
+    bool is_unsigned = is_unsigned<T>::value,
+    std::size_t size_t_bits = sizeof(std::size_t) * CHAR_BIT,
+    std::size_t type_bits = sizeof(T) * CHAR_BIT>
+struct hash_integral_impl;
+
+template<class T, bool is_unsigned, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, false, is_unsigned, size_t_bits, type_bits>
+{
+    static std::size_t fn( T v )
+    {
+        return static_cast<std::size_t>( v );
+    }
+};
+
+template<class T, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, true, false, size_t_bits, type_bits>
+{
+    static std::size_t fn( T v )
+    {
+        typedef typename make_unsigned<T>::type U;
+
+        if( v >= 0 )
+        {
+            return hash_integral_impl<U>::fn( static_cast<U>( v ) );
+        }
+        else
+        {
+            return ~hash_integral_impl<U>::fn( static_cast<U>( ~static_cast<U>( v ) ) );
+        }
+    }
+};
+
+template<class T> struct hash_integral_impl<T, true, true, 32, 64>
+{
+    static std::size_t fn( T v )
+    {
+        std::size_t seed = 0;
+
+        seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
+        seed = static_cast<std::size_t>( v  & 0xFFFFFFFF ) + hash_detail::hash_mix( seed );
+
+        return seed;
+    }
+};
+
+template<class T> struct hash_integral_impl<T, true, true, 32, 128>
+{
+    static std::size_t fn( T v )
+    {
+        std::size_t seed = 0;
+
+        seed = static_cast<std::size_t>( v >> 96 ) + hash_detail::hash_mix( seed );
+        seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
+        seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
+        seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
+
+        return seed;
+    }
+};
+
+template<class T> struct hash_integral_impl<T, true, true, 64, 128>
+{
+    static std::size_t fn( T v )
+    {
+        std::size_t seed = 0;
+
+        seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
+        seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
+
+        return seed;
+    }
+};
+
+} // namespace hash_detail
+
+template <typename T>
+typename std::enable_if<hash_detail::is_integral<T>::value, std::size_t>::type
+    hash_value( T v )
+{
+    return hash_detail::hash_integral_impl<T>::fn( v );
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_HASH_DETAIL_HASH_INTEGRAL_HPP

data/src/cxx_supportlib/vendor-modified/boost/container_hash/detail/hash_mix.hpp

@@ -5,7 +5,7 @@
 #ifndef BOOST_HASH_DETAIL_HASH_MIX_HPP
 #define BOOST_HASH_DETAIL_HASH_MIX_HPP
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <cstddef>
 #include <climits>
 
@@ -66,9 +66,9 @@ template<std::size_t Bits> struct hash_mix_impl;
 
 template<> struct hash_mix_impl<64>
 {
-    inline static boost::uint64_t fn( boost::uint64_t x )
+    inline static std::uint64_t fn( std::uint64_t x )
     {
-        boost::uint64_t const m = (boost::uint64_t(0xe9846af) << 32) + 0x9b1a615d;
+        std::uint64_t const m = 0xe9846af9b1a615d;
 
         x ^= x >> 32;
         x *= m;
@@ -87,10 +87,10 @@ template<> struct hash_mix_impl<64>
 
 template<> struct hash_mix_impl<32>
 {
-    inline static boost::uint32_t fn( boost::uint32_t x )
+    inline static std::uint32_t fn( std::uint32_t x )
     {
-        boost::uint32_t const m1 = 0x21f0aaad;
-        boost::uint32_t const m2 = 0x735a2d97;
+        std::uint32_t const m1 = 0x21f0aaad;
+        std::uint32_t const m2 = 0x735a2d97;
 
         x ^= x >> 16;
         x *= m1;

data/src/cxx_supportlib/vendor-modified/boost/container_hash/detail/hash_range.hpp

@@ -7,10 +7,8 @@
 
 #include <boost/container_hash/hash_fwd.hpp>
 #include <boost/container_hash/detail/mulx.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/cstdint.hpp>
+#include <type_traits>
+#include <cstdint>
 #include <iterator>
 #include <limits>
 #include <cstddef>
@@ -22,20 +20,20 @@ namespace boost
 namespace hash_detail
 {
 
-template<class T> struct is_char_type: public boost::false_type {};
+template<class T> struct is_char_type: public std::false_type {};
 
 #if CHAR_BIT == 8
 
-template<> struct is_char_type<char>: public boost::true_type {};
-template<> struct is_char_type<signed char>: public boost::true_type {};
-template<> struct is_char_type<unsigned char>: public boost::true_type {};
+template<> struct is_char_type<char>: public std::true_type {};
+template<> struct is_char_type<signed char>: public std::true_type {};
+template<> struct is_char_type<unsigned char>: public std::true_type {};
 
 #if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
-template<> struct is_char_type<char8_t>: public boost::true_type {};
+template<> struct is_char_type<char8_t>: public std::true_type {};
 #endif
 
 #if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
-template<> struct is_char_type<std::byte>: public boost::true_type {};
+template<> struct is_char_type<std::byte>: public std::true_type {};
 #endif
 
 #endif
@@ -43,7 +41,7 @@ template<> struct is_char_type<std::byte>: public boost::true_type {};
 // generic version
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     !is_char_type<typename std::iterator_traits<It>::value_type>::value,
 std::size_t >::type
     hash_range( std::size_t seed, It first, It last )
@@ -58,25 +56,25 @@ std::size_t >::type
 
 // specialized char[] version, 32 bit
 
-template<class It> inline boost::uint32_t read32le( It p )
+template<class It> inline std::uint32_t read32le( It p )
 {
     // clang 5+, gcc 5+ figure out this pattern and use a single mov on x86
     // gcc on s390x and power BE even knows how to use load-reverse
 
-    boost::uint32_t w =
-        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[0] ) ) |
-        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[1] ) ) <<  8 |
-        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
-        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[3] ) ) << 24;
+    std::uint32_t w =
+        static_cast<std::uint32_t>( static_cast<unsigned char>( p[0] ) ) |
+        static_cast<std::uint32_t>( static_cast<unsigned char>( p[1] ) ) <<  8 |
+        static_cast<std::uint32_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
+        static_cast<std::uint32_t>( static_cast<unsigned char>( p[3] ) ) << 24;
 
     return w;
 }
 
 #if defined(_MSC_VER) && !defined(__clang__)
 
-template<class T> inline boost::uint32_t read32le( T* p )
+template<class T> inline std::uint32_t read32le( T* p )
 {
-    boost::uint32_t w;
+    std::uint32_t w;
 
     std::memcpy( &w, p, 4 );
     return w;
@@ -84,15 +82,15 @@ template<class T> inline boost::uint32_t read32le( T* p )
 
 #endif
 
-inline boost::uint64_t mul32( boost::uint32_t x, boost::uint32_t y )
+inline std::uint64_t mul32( std::uint32_t x, std::uint32_t y )
 {
-    return static_cast<boost::uint64_t>( x ) * y;
+    return static_cast<std::uint64_t>( x ) * y;
 }
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     is_char_type<typename std::iterator_traits<It>::value_type>::value &&
-    is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
+    std::is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
     std::numeric_limits<std::size_t>::digits <= 32,
 std::size_t>::type
     hash_range( std::size_t seed, It first, It last )
@@ -100,17 +98,17 @@ std::size_t>::type
     It p = first;
     std::size_t n = static_cast<std::size_t>( last - first );
 
-    boost::uint32_t const q = 0x9e3779b9U;
-    boost::uint32_t const k = 0xe35e67b1U; // q * q
+    std::uint32_t const q = 0x9e3779b9U;
+    std::uint32_t const k = 0xe35e67b1U; // q * q
 
-    boost::uint64_t h = mul32( static_cast<boost::uint32_t>( seed ) + q, k );
-    boost::uint32_t w = static_cast<boost::uint32_t>( h & 0xFFFFFFFF );
+    std::uint64_t h = mul32( static_cast<std::uint32_t>( seed ) + q, k );
+    std::uint32_t w = static_cast<std::uint32_t>( h & 0xFFFFFFFF );
 
     h ^= n;
 
     while( n >= 4 )
     {
-        boost::uint32_t v1 = read32le( p );
+        std::uint32_t v1 = read32le( p );
 
         w += q;
         h ^= mul32( v1 + w, k );
@@ -120,7 +118,7 @@ std::size_t>::type
     }
 
     {
-        boost::uint32_t v1 = 0;
+        std::uint32_t v1 = 0;
 
         if( n >= 1 )
         {
@@ -128,9 +126,9 @@ std::size_t>::type
             std::size_t const x2 = n >> 1;        // 1: 0, 2: 1, 3: 1
 
             v1 =
-                static_cast<boost::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
-                static_cast<boost::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
-                static_cast<boost::uint32_t>( static_cast<unsigned char>( p[ 0 ] ) );
+                static_cast<std::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
+                static_cast<std::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
+                static_cast<std::uint32_t>( static_cast<unsigned char>( p[ 0 ] ) );
         }
 
         w += q;
@@ -138,28 +136,28 @@ std::size_t>::type
     }
 
     w += q;
-    h ^= mul32( static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<boost::uint32_t>( h >> 32 ) + w + k );
+    h ^= mul32( static_cast<std::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<std::uint32_t>( h >> 32 ) + w + k );
 
-    return static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<boost::uint32_t>( h >> 32 );
+    return static_cast<std::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<std::uint32_t>( h >> 32 );
 }
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     is_char_type<typename std::iterator_traits<It>::value_type>::value &&
-    !is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
+    !std::is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
     std::numeric_limits<std::size_t>::digits <= 32,
 std::size_t>::type
     hash_range( std::size_t seed, It first, It last )
 {
     std::size_t n = 0;
 
-    boost::uint32_t const q = 0x9e3779b9U;
-    boost::uint32_t const k = 0xe35e67b1U; // q * q
+    std::uint32_t const q = 0x9e3779b9U;
+    std::uint32_t const k = 0xe35e67b1U; // q * q
 
-    boost::uint64_t h = mul32( static_cast<boost::uint32_t>( seed ) + q, k );
-    boost::uint32_t w = static_cast<boost::uint32_t>( h & 0xFFFFFFFF );
+    std::uint64_t h = mul32( static_cast<std::uint32_t>( seed ) + q, k );
+    std::uint32_t w = static_cast<std::uint32_t>( h & 0xFFFFFFFF );
 
-    boost::uint32_t v1 = 0;
+    std::uint32_t v1 = 0;
 
     for( ;; )
     {
@@ -170,7 +168,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) );
+        v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) );
         ++first;
         ++n;
 
@@ -179,7 +177,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 8;
+        v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) ) << 8;
         ++first;
         ++n;
 
@@ -188,7 +186,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 16;
+        v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) ) << 16;
         ++first;
         ++n;
 
@@ -197,7 +195,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 24;
+        v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) ) << 24;
         ++first;
         ++n;
 
@@ -211,33 +209,33 @@ std::size_t>::type
     h ^= mul32( v1 + w, k );
 
     w += q;
-    h ^= mul32( static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<boost::uint32_t>( h >> 32 ) + w + k );
+    h ^= mul32( static_cast<std::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<std::uint32_t>( h >> 32 ) + w + k );
 
-    return static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<boost::uint32_t>( h >> 32 );
+    return static_cast<std::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<std::uint32_t>( h >> 32 );
 }
 
 // specialized char[] version, 64 bit
 
-template<class It> inline boost::uint64_t read64le( It p )
+template<class It> inline std::uint64_t read64le( It p )
 {
-    boost::uint64_t w =
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[0] ) ) |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[1] ) ) <<  8 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[3] ) ) << 24 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[4] ) ) << 32 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[5] ) ) << 40 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[6] ) ) << 48 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[7] ) ) << 56;
+    std::uint64_t w =
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[0] ) ) |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[1] ) ) <<  8 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[3] ) ) << 24 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[4] ) ) << 32 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[5] ) ) << 40 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[6] ) ) << 48 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[7] ) ) << 56;
 
     return w;
 }
 
 #if defined(_MSC_VER) && !defined(__clang__)
 
-template<class T> inline boost::uint64_t read64le( T* p )
+template<class T> inline std::uint64_t read64le( T* p )
 {
-    boost::uint64_t w;
+    std::uint64_t w;
 
     std::memcpy( &w, p, 8 );
     return w;
@@ -246,9 +244,9 @@ template<class T> inline boost::uint64_t read64le( T* p )
 #endif
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     is_char_type<typename std::iterator_traits<It>::value_type>::value &&
-    is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
+    std::is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
     (std::numeric_limits<std::size_t>::digits > 32),
 std::size_t>::type
     hash_range( std::size_t seed, It first, It last )
@@ -256,15 +254,15 @@ std::size_t>::type
     It p = first;
     std::size_t n = static_cast<std::size_t>( last - first );
 
-    boost::uint64_t const q = static_cast<boost::uint64_t>( 0x9e3779b9 ) << 32 | 0x7f4a7c15;
-    boost::uint64_t const k = static_cast<boost::uint64_t>( 0xdf442d22 ) << 32 | 0xce4859b9; // q * q
+    std::uint64_t const q = 0x9e3779b97f4a7c15;
+    std::uint64_t const k = 0xdf442d22ce4859b9; // q * q
 
-    boost::uint64_t w = mulx( seed + q, k );
-    boost::uint64_t h = w ^ n;
+    std::uint64_t w = mulx( seed + q, k );
+    std::uint64_t h = w ^ n;
 
     while( n >= 8 )
     {
-        boost::uint64_t v1 = read64le( p );
+        std::uint64_t v1 = read64le( p );
 
         w += q;
         h ^= mulx( v1 + w, k );
@@ -274,11 +272,11 @@ std::size_t>::type
     }
 
     {
-        boost::uint64_t v1 = 0;
+        std::uint64_t v1 = 0;
 
         if( n >= 4 )
         {
-            v1 = static_cast<boost::uint64_t>( read32le( p + static_cast<std::ptrdiff_t>( n - 4 ) ) ) << ( n - 4 ) * 8 | read32le( p );
+            v1 = static_cast<std::uint64_t>( read32le( p + static_cast<std::ptrdiff_t>( n - 4 ) ) ) << ( n - 4 ) * 8 | read32le( p );
         }
         else if( n >= 1 )
         {
@@ -286,9 +284,9 @@ std::size_t>::type
             std::size_t const x2 = n >> 1;        // 1: 0, 2: 1, 3: 1
 
             v1 =
-                static_cast<boost::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
-                static_cast<boost::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
-                static_cast<boost::uint64_t>( static_cast<unsigned char>( p[ 0 ] ) );
+                static_cast<std::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
+                static_cast<std::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
+                static_cast<std::uint64_t>( static_cast<unsigned char>( p[ 0 ] ) );
         }
 
         w += q;
@@ -299,22 +297,22 @@ std::size_t>::type
 }
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     is_char_type<typename std::iterator_traits<It>::value_type>::value &&
-    !is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
+    !std::is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
     (std::numeric_limits<std::size_t>::digits > 32),
 std::size_t>::type
     hash_range( std::size_t seed, It first, It last )
 {
     std::size_t n = 0;
 
-    boost::uint64_t const q = static_cast<boost::uint64_t>( 0x9e3779b9 ) << 32 | 0x7f4a7c15;
-    boost::uint64_t const k = static_cast<boost::uint64_t>( 0xdf442d22 ) << 32 | 0xce4859b9; // q * q
+    std::uint64_t const q = 0x9e3779b97f4a7c15;
+    std::uint64_t const k = 0xdf442d22ce4859b9; // q * q
 
-    boost::uint64_t w = mulx( seed + q, k );
-    boost::uint64_t h = w;
+    std::uint64_t w = mulx( seed + q, k );
+    std::uint64_t h = w;
 
-    boost::uint64_t v1 = 0;
+    std::uint64_t v1 = 0;
 
     for( ;; )
     {
@@ -325,7 +323,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) );
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) );
         ++first;
         ++n;
 
@@ -334,7 +332,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 8;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 8;
         ++first;
         ++n;
 
@@ -343,7 +341,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 16;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 16;
         ++first;
         ++n;
 
@@ -352,7 +350,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 24;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 24;
         ++first;
         ++n;
 
@@ -361,7 +359,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 32;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 32;
         ++first;
         ++n;
 
@@ -370,7 +368,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 40;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 40;
         ++first;
         ++n;
 
@@ -379,7 +377,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 48;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 48;
         ++first;
         ++n;
 
@@ -388,7 +386,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 56;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 56;
         ++first;
         ++n;