xref: /netbsd-src/external/apache2/llvm/dist/libcxx/include/utility (revision 4d6fc14bc9b0c5bf3e30be318c143ee82cadd108)
1*4d6fc14bSjoerg// -*- C++ -*-
2*4d6fc14bSjoerg//===-------------------------- utility -----------------------------------===//
3*4d6fc14bSjoerg//
4*4d6fc14bSjoerg// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5*4d6fc14bSjoerg// See https://llvm.org/LICENSE.txt for license information.
6*4d6fc14bSjoerg// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7*4d6fc14bSjoerg//
8*4d6fc14bSjoerg//===----------------------------------------------------------------------===//
9*4d6fc14bSjoerg
10*4d6fc14bSjoerg#ifndef _LIBCPP_UTILITY
11*4d6fc14bSjoerg#define _LIBCPP_UTILITY
12*4d6fc14bSjoerg
13*4d6fc14bSjoerg/*
14*4d6fc14bSjoerg    utility synopsis
15*4d6fc14bSjoerg
16*4d6fc14bSjoerg#include <initializer_list>
17*4d6fc14bSjoerg
18*4d6fc14bSjoergnamespace std
19*4d6fc14bSjoerg{
20*4d6fc14bSjoerg
21*4d6fc14bSjoergtemplate <class T>
22*4d6fc14bSjoerg    void
23*4d6fc14bSjoerg    swap(T& a, T& b);
24*4d6fc14bSjoerg
25*4d6fc14bSjoergnamespace rel_ops
26*4d6fc14bSjoerg{
27*4d6fc14bSjoerg    template<class T> bool operator!=(const T&, const T&);
28*4d6fc14bSjoerg    template<class T> bool operator> (const T&, const T&);
29*4d6fc14bSjoerg    template<class T> bool operator<=(const T&, const T&);
30*4d6fc14bSjoerg    template<class T> bool operator>=(const T&, const T&);
31*4d6fc14bSjoerg}
32*4d6fc14bSjoerg
33*4d6fc14bSjoergtemplate<class T>
34*4d6fc14bSjoergvoid
35*4d6fc14bSjoergswap(T& a, T& b) noexcept(is_nothrow_move_constructible<T>::value &&
36*4d6fc14bSjoerg                          is_nothrow_move_assignable<T>::value);
37*4d6fc14bSjoerg
38*4d6fc14bSjoergtemplate <class T, size_t N>
39*4d6fc14bSjoergvoid
40*4d6fc14bSjoergswap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b)));
41*4d6fc14bSjoerg
42*4d6fc14bSjoergtemplate <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;  // constexpr in C++14
43*4d6fc14bSjoergtemplate <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept; // constexpr in C++14
44*4d6fc14bSjoerg
45*4d6fc14bSjoergtemplate <class T> typename remove_reference<T>::type&& move(T&&) noexcept;      // constexpr in C++14
46*4d6fc14bSjoerg
47*4d6fc14bSjoergtemplate <class T>
48*4d6fc14bSjoerg    typename conditional
49*4d6fc14bSjoerg    <
50*4d6fc14bSjoerg        !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
51*4d6fc14bSjoerg        const T&,
52*4d6fc14bSjoerg        T&&
53*4d6fc14bSjoerg    >::type
54*4d6fc14bSjoerg    move_if_noexcept(T& x) noexcept; // constexpr in C++14
55*4d6fc14bSjoerg
56*4d6fc14bSjoergtemplate <class T> constexpr add_const_t<T>& as_const(T& t) noexcept;      // C++17
57*4d6fc14bSjoergtemplate <class T>                      void as_const(const T&&) = delete; // C++17
58*4d6fc14bSjoerg
59*4d6fc14bSjoergtemplate <class T> typename add_rvalue_reference<T>::type declval() noexcept;
60*4d6fc14bSjoerg
61*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_equal(T t, U u) noexcept;         // C++20
62*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_not_equal(T t, U u) noexcept;     // C++20
63*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_less(T t, U u) noexcept;          // C++20
64*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_greater(T t, U u) noexcept;       // C++20
65*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_less_equal(T t, U u) noexcept;    // C++20
66*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
67*4d6fc14bSjoergtemplate<class R, class T> constexpr bool in_range(T t) noexcept;               // C++20
68*4d6fc14bSjoerg
69*4d6fc14bSjoergtemplate <class T1, class T2>
70*4d6fc14bSjoergstruct pair
71*4d6fc14bSjoerg{
72*4d6fc14bSjoerg    typedef T1 first_type;
73*4d6fc14bSjoerg    typedef T2 second_type;
74*4d6fc14bSjoerg
75*4d6fc14bSjoerg    T1 first;
76*4d6fc14bSjoerg    T2 second;
77*4d6fc14bSjoerg
78*4d6fc14bSjoerg    pair(const pair&) = default;
79*4d6fc14bSjoerg    pair(pair&&) = default;
80*4d6fc14bSjoerg    explicit(see-below) constexpr pair();
81*4d6fc14bSjoerg    explicit(see-below) pair(const T1& x, const T2& y);                          // constexpr in C++14
82*4d6fc14bSjoerg    template <class U, class V> explicit(see-below) pair(U&& x, V&& y);          // constexpr in C++14
83*4d6fc14bSjoerg    template <class U, class V> explicit(see-below) pair(const pair<U, V>& p);   // constexpr in C++14
84*4d6fc14bSjoerg    template <class U, class V> explicit(see-below) pair(pair<U, V>&& p);        // constexpr in C++14
85*4d6fc14bSjoerg    template <class... Args1, class... Args2>
86*4d6fc14bSjoerg        pair(piecewise_construct_t, tuple<Args1...> first_args,
87*4d6fc14bSjoerg             tuple<Args2...> second_args);                                       // constexpr in C++20
88*4d6fc14bSjoerg
89*4d6fc14bSjoerg    template <class U, class V> pair& operator=(const pair<U, V>& p);            // constexpr in C++20
90*4d6fc14bSjoerg    pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
91*4d6fc14bSjoerg                                       is_nothrow_move_assignable<T2>::value);   // constexpr in C++20
92*4d6fc14bSjoerg    template <class U, class V> pair& operator=(pair<U, V>&& p);                 // constexpr in C++20
93*4d6fc14bSjoerg
94*4d6fc14bSjoerg    void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> &&
95*4d6fc14bSjoerg                                is_nothrow_swappable_v<T2>);                     // constexpr in C++20
96*4d6fc14bSjoerg};
97*4d6fc14bSjoerg
98*4d6fc14bSjoergtemplate <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
99*4d6fc14bSjoergtemplate <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
100*4d6fc14bSjoergtemplate <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
101*4d6fc14bSjoergtemplate <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
102*4d6fc14bSjoergtemplate <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
103*4d6fc14bSjoergtemplate <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
104*4d6fc14bSjoerg
105*4d6fc14bSjoergtemplate <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);                // constexpr in C++14
106*4d6fc14bSjoergtemplate <class T1, class T2>
107*4d6fc14bSjoergvoid
108*4d6fc14bSjoergswap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));            // constexpr in C++20
109*4d6fc14bSjoerg
110*4d6fc14bSjoergstruct piecewise_construct_t { explicit piecewise_construct_t() = default; };
111*4d6fc14bSjoerginline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
112*4d6fc14bSjoerg
113*4d6fc14bSjoergtemplate <class T> struct tuple_size;
114*4d6fc14bSjoergtemplate <size_t I, class T> struct tuple_element;
115*4d6fc14bSjoerg
116*4d6fc14bSjoergtemplate <class T1, class T2> struct tuple_size<pair<T1, T2> >;
117*4d6fc14bSjoergtemplate <class T1, class T2> struct tuple_element<0, pair<T1, T2> >;
118*4d6fc14bSjoergtemplate <class T1, class T2> struct tuple_element<1, pair<T1, T2> >;
119*4d6fc14bSjoerg
120*4d6fc14bSjoergtemplate<size_t I, class T1, class T2>
121*4d6fc14bSjoerg    typename tuple_element<I, pair<T1, T2> >::type&
122*4d6fc14bSjoerg    get(pair<T1, T2>&) noexcept; // constexpr in C++14
123*4d6fc14bSjoerg
124*4d6fc14bSjoergtemplate<size_t I, class T1, class T2>
125*4d6fc14bSjoerg    const typename tuple_element<I, pair<T1, T2> >::type&
126*4d6fc14bSjoerg    get(const pair<T1, T2>&) noexcept; // constexpr in C++14
127*4d6fc14bSjoerg
128*4d6fc14bSjoergtemplate<size_t I, class T1, class T2>
129*4d6fc14bSjoerg    typename tuple_element<I, pair<T1, T2> >::type&&
130*4d6fc14bSjoerg    get(pair<T1, T2>&&) noexcept; // constexpr in C++14
131*4d6fc14bSjoerg
132*4d6fc14bSjoergtemplate<size_t I, class T1, class T2>
133*4d6fc14bSjoerg    const typename tuple_element<I, pair<T1, T2> >::type&&
134*4d6fc14bSjoerg    get(const pair<T1, T2>&&) noexcept; // constexpr in C++14
135*4d6fc14bSjoerg
136*4d6fc14bSjoergtemplate<class T1, class T2>
137*4d6fc14bSjoerg    constexpr T1& get(pair<T1, T2>&) noexcept; // C++14
138*4d6fc14bSjoerg
139*4d6fc14bSjoergtemplate<class T1, class T2>
140*4d6fc14bSjoerg    constexpr const T1& get(const pair<T1, T2>&) noexcept; // C++14
141*4d6fc14bSjoerg
142*4d6fc14bSjoergtemplate<class T1, class T2>
143*4d6fc14bSjoerg    constexpr T1&& get(pair<T1, T2>&&) noexcept; // C++14
144*4d6fc14bSjoerg
145*4d6fc14bSjoergtemplate<class T1, class T2>
146*4d6fc14bSjoerg    constexpr const T1&& get(const pair<T1, T2>&&) noexcept; // C++14
147*4d6fc14bSjoerg
148*4d6fc14bSjoergtemplate<class T1, class T2>
149*4d6fc14bSjoerg    constexpr T1& get(pair<T2, T1>&) noexcept; // C++14
150*4d6fc14bSjoerg
151*4d6fc14bSjoergtemplate<class T1, class T2>
152*4d6fc14bSjoerg    constexpr const T1& get(const pair<T2, T1>&) noexcept; // C++14
153*4d6fc14bSjoerg
154*4d6fc14bSjoergtemplate<class T1, class T2>
155*4d6fc14bSjoerg    constexpr T1&& get(pair<T2, T1>&&) noexcept; // C++14
156*4d6fc14bSjoerg
157*4d6fc14bSjoergtemplate<class T1, class T2>
158*4d6fc14bSjoerg    constexpr const T1&& get(const pair<T2, T1>&&) noexcept; // C++14
159*4d6fc14bSjoerg
160*4d6fc14bSjoerg// C++14
161*4d6fc14bSjoerg
162*4d6fc14bSjoergtemplate<class T, T... I>
163*4d6fc14bSjoergstruct integer_sequence
164*4d6fc14bSjoerg{
165*4d6fc14bSjoerg    typedef T value_type;
166*4d6fc14bSjoerg
167*4d6fc14bSjoerg    static constexpr size_t size() noexcept;
168*4d6fc14bSjoerg};
169*4d6fc14bSjoerg
170*4d6fc14bSjoergtemplate<size_t... I>
171*4d6fc14bSjoerg  using index_sequence = integer_sequence<size_t, I...>;
172*4d6fc14bSjoerg
173*4d6fc14bSjoergtemplate<class T, T N>
174*4d6fc14bSjoerg  using make_integer_sequence = integer_sequence<T, 0, 1, ..., N-1>;
175*4d6fc14bSjoergtemplate<size_t N>
176*4d6fc14bSjoerg  using make_index_sequence = make_integer_sequence<size_t, N>;
177*4d6fc14bSjoerg
178*4d6fc14bSjoergtemplate<class... T>
179*4d6fc14bSjoerg  using index_sequence_for = make_index_sequence<sizeof...(T)>;
180*4d6fc14bSjoerg
181*4d6fc14bSjoergtemplate<class T, class U=T>
182*4d6fc14bSjoerg    T exchange(T& obj, U&& new_value);
183*4d6fc14bSjoerg
184*4d6fc14bSjoerg// 20.2.7, in-place construction // C++17
185*4d6fc14bSjoergstruct in_place_t {
186*4d6fc14bSjoerg  explicit in_place_t() = default;
187*4d6fc14bSjoerg};
188*4d6fc14bSjoerginline constexpr in_place_t in_place{};
189*4d6fc14bSjoergtemplate <class T>
190*4d6fc14bSjoerg  struct in_place_type_t {
191*4d6fc14bSjoerg    explicit in_place_type_t() = default;
192*4d6fc14bSjoerg  };
193*4d6fc14bSjoergtemplate <class T>
194*4d6fc14bSjoerg  inline constexpr in_place_type_t<T> in_place_type{};
195*4d6fc14bSjoergtemplate <size_t I>
196*4d6fc14bSjoerg  struct in_place_index_t {
197*4d6fc14bSjoerg    explicit in_place_index_t() = default;
198*4d6fc14bSjoerg  };
199*4d6fc14bSjoergtemplate <size_t I>
200*4d6fc14bSjoerg  inline constexpr in_place_index_t<I> in_place_index{};
201*4d6fc14bSjoerg
202*4d6fc14bSjoerg// [utility.underlying], to_underlying
203*4d6fc14bSjoergtemplate <class T>
204*4d6fc14bSjoerg    constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
205*4d6fc14bSjoerg
206*4d6fc14bSjoerg}  // std
207*4d6fc14bSjoerg
208*4d6fc14bSjoerg*/
209*4d6fc14bSjoerg
210*4d6fc14bSjoerg#include <__config>
211*4d6fc14bSjoerg#include <__tuple>
212*4d6fc14bSjoerg#include <__utility/to_underlying.h>
213*4d6fc14bSjoerg#include <compare>
214*4d6fc14bSjoerg#include <type_traits>
215*4d6fc14bSjoerg#include <initializer_list>
216*4d6fc14bSjoerg#include <cstddef>
217*4d6fc14bSjoerg#include <cstring>
218*4d6fc14bSjoerg#include <cstdint>
219*4d6fc14bSjoerg#include <limits>
220*4d6fc14bSjoerg#include <version>
221*4d6fc14bSjoerg#include <__debug>
222*4d6fc14bSjoerg
223*4d6fc14bSjoerg#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
224*4d6fc14bSjoerg#pragma GCC system_header
225*4d6fc14bSjoerg#endif
226*4d6fc14bSjoerg
227*4d6fc14bSjoerg_LIBCPP_PUSH_MACROS
228*4d6fc14bSjoerg#include <__undef_macros>
229*4d6fc14bSjoerg
230*4d6fc14bSjoerg_LIBCPP_BEGIN_NAMESPACE_STD
231*4d6fc14bSjoerg
232*4d6fc14bSjoergnamespace rel_ops
233*4d6fc14bSjoerg{
234*4d6fc14bSjoerg
235*4d6fc14bSjoergtemplate<class _Tp>
236*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
237*4d6fc14bSjoergbool
238*4d6fc14bSjoergoperator!=(const _Tp& __x, const _Tp& __y)
239*4d6fc14bSjoerg{
240*4d6fc14bSjoerg    return !(__x == __y);
241*4d6fc14bSjoerg}
242*4d6fc14bSjoerg
243*4d6fc14bSjoergtemplate<class _Tp>
244*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
245*4d6fc14bSjoergbool
246*4d6fc14bSjoergoperator> (const _Tp& __x, const _Tp& __y)
247*4d6fc14bSjoerg{
248*4d6fc14bSjoerg    return __y < __x;
249*4d6fc14bSjoerg}
250*4d6fc14bSjoerg
251*4d6fc14bSjoergtemplate<class _Tp>
252*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
253*4d6fc14bSjoergbool
254*4d6fc14bSjoergoperator<=(const _Tp& __x, const _Tp& __y)
255*4d6fc14bSjoerg{
256*4d6fc14bSjoerg    return !(__y < __x);
257*4d6fc14bSjoerg}
258*4d6fc14bSjoerg
259*4d6fc14bSjoergtemplate<class _Tp>
260*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
261*4d6fc14bSjoergbool
262*4d6fc14bSjoergoperator>=(const _Tp& __x, const _Tp& __y)
263*4d6fc14bSjoerg{
264*4d6fc14bSjoerg    return !(__x < __y);
265*4d6fc14bSjoerg}
266*4d6fc14bSjoerg
267*4d6fc14bSjoerg}  // rel_ops
268*4d6fc14bSjoerg
269*4d6fc14bSjoerg// swap_ranges is defined in <type_traits>`
270*4d6fc14bSjoerg
271*4d6fc14bSjoerg// swap is defined in <type_traits>
272*4d6fc14bSjoerg
273*4d6fc14bSjoerg// move_if_noexcept
274*4d6fc14bSjoerg
275*4d6fc14bSjoergtemplate <class _Tp>
276*4d6fc14bSjoerg_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
277*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG
278*4d6fc14bSjoergtypename conditional
279*4d6fc14bSjoerg<
280*4d6fc14bSjoerg    !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value,
281*4d6fc14bSjoerg    const _Tp&,
282*4d6fc14bSjoerg    _Tp&&
283*4d6fc14bSjoerg>::type
284*4d6fc14bSjoerg#else  // _LIBCPP_CXX03_LANG
285*4d6fc14bSjoergconst _Tp&
286*4d6fc14bSjoerg#endif
287*4d6fc14bSjoergmove_if_noexcept(_Tp& __x) _NOEXCEPT
288*4d6fc14bSjoerg{
289*4d6fc14bSjoerg    return _VSTD::move(__x);
290*4d6fc14bSjoerg}
291*4d6fc14bSjoerg
292*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 14
293*4d6fc14bSjoergtemplate <class _Tp>
294*4d6fc14bSjoerg_LIBCPP_NODISCARD_EXT constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
295*4d6fc14bSjoerg
296*4d6fc14bSjoergtemplate <class _Tp>
297*4d6fc14bSjoergvoid as_const(const _Tp&&) = delete;
298*4d6fc14bSjoerg#endif
299*4d6fc14bSjoerg
300*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
301*4d6fc14bSjoergtemplate<class _Tp, class... _Up>
302*4d6fc14bSjoergstruct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {};
303*4d6fc14bSjoerg
304*4d6fc14bSjoergtemplate<class _Tp>
305*4d6fc14bSjoergconcept __is_safe_integral_cmp = is_integral_v<_Tp> &&
306*4d6fc14bSjoerg                      !_IsSameAsAny<_Tp, bool, char,
307*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_CHAR8_T
308*4d6fc14bSjoerg                                    char8_t,
309*4d6fc14bSjoerg#endif
310*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
311*4d6fc14bSjoerg                                    char16_t, char32_t,
312*4d6fc14bSjoerg#endif
313*4d6fc14bSjoerg                                    wchar_t>::value;
314*4d6fc14bSjoerg
315*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
316*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr
317*4d6fc14bSjoergbool cmp_equal(_Tp __t, _Up __u) noexcept
318*4d6fc14bSjoerg{
319*4d6fc14bSjoerg  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
320*4d6fc14bSjoerg    return __t == __u;
321*4d6fc14bSjoerg  else if constexpr (is_signed_v<_Tp>)
322*4d6fc14bSjoerg    return __t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u;
323*4d6fc14bSjoerg  else
324*4d6fc14bSjoerg    return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u);
325*4d6fc14bSjoerg}
326*4d6fc14bSjoerg
327*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
328*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr
329*4d6fc14bSjoergbool cmp_not_equal(_Tp __t, _Up __u) noexcept
330*4d6fc14bSjoerg{
331*4d6fc14bSjoerg  return !_VSTD::cmp_equal(__t, __u);
332*4d6fc14bSjoerg}
333*4d6fc14bSjoerg
334*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
335*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr
336*4d6fc14bSjoergbool cmp_less(_Tp __t, _Up __u) noexcept
337*4d6fc14bSjoerg{
338*4d6fc14bSjoerg  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
339*4d6fc14bSjoerg    return __t < __u;
340*4d6fc14bSjoerg  else if constexpr (is_signed_v<_Tp>)
341*4d6fc14bSjoerg    return __t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u;
342*4d6fc14bSjoerg  else
343*4d6fc14bSjoerg    return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u);
344*4d6fc14bSjoerg}
345*4d6fc14bSjoerg
346*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
347*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr
348*4d6fc14bSjoergbool cmp_greater(_Tp __t, _Up __u) noexcept
349*4d6fc14bSjoerg{
350*4d6fc14bSjoerg  return _VSTD::cmp_less(__u, __t);
351*4d6fc14bSjoerg}
352*4d6fc14bSjoerg
353*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
354*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr
355*4d6fc14bSjoergbool cmp_less_equal(_Tp __t, _Up __u) noexcept
356*4d6fc14bSjoerg{
357*4d6fc14bSjoerg  return !_VSTD::cmp_greater(__t, __u);
358*4d6fc14bSjoerg}
359*4d6fc14bSjoerg
360*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
361*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr
362*4d6fc14bSjoergbool cmp_greater_equal(_Tp __t, _Up __u) noexcept
363*4d6fc14bSjoerg{
364*4d6fc14bSjoerg  return !_VSTD::cmp_less(__t, __u);
365*4d6fc14bSjoerg}
366*4d6fc14bSjoerg
367*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
368*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr
369*4d6fc14bSjoergbool in_range(_Up __u) noexcept
370*4d6fc14bSjoerg{
371*4d6fc14bSjoerg  return _VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max()) &&
372*4d6fc14bSjoerg         _VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
373*4d6fc14bSjoerg}
374*4d6fc14bSjoerg#endif
375*4d6fc14bSjoerg
376*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { explicit piecewise_construct_t() = default; };
377*4d6fc14bSjoerg#if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)
378*4d6fc14bSjoergextern _LIBCPP_EXPORTED_FROM_ABI const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
379*4d6fc14bSjoerg#else
380*4d6fc14bSjoerg/* _LIBCPP_INLINE_VAR */ constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
381*4d6fc14bSjoerg#endif
382*4d6fc14bSjoerg
383*4d6fc14bSjoerg#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
384*4d6fc14bSjoergtemplate <class, class>
385*4d6fc14bSjoergstruct __non_trivially_copyable_base {
386*4d6fc14bSjoerg  _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
387*4d6fc14bSjoerg  __non_trivially_copyable_base() _NOEXCEPT {}
388*4d6fc14bSjoerg  _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
389*4d6fc14bSjoerg  __non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}
390*4d6fc14bSjoerg};
391*4d6fc14bSjoerg#endif
392*4d6fc14bSjoerg
393*4d6fc14bSjoergtemplate <class _T1, class _T2>
394*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS pair
395*4d6fc14bSjoerg#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
396*4d6fc14bSjoerg: private __non_trivially_copyable_base<_T1, _T2>
397*4d6fc14bSjoerg#endif
398*4d6fc14bSjoerg{
399*4d6fc14bSjoerg    typedef _T1 first_type;
400*4d6fc14bSjoerg    typedef _T2 second_type;
401*4d6fc14bSjoerg
402*4d6fc14bSjoerg    _T1 first;
403*4d6fc14bSjoerg    _T2 second;
404*4d6fc14bSjoerg
405*4d6fc14bSjoerg#if !defined(_LIBCPP_CXX03_LANG)
406*4d6fc14bSjoerg    pair(pair const&) = default;
407*4d6fc14bSjoerg    pair(pair&&) = default;
408*4d6fc14bSjoerg#else
409*4d6fc14bSjoerg  // Use the implicitly declared copy constructor in C++03
410*4d6fc14bSjoerg#endif
411*4d6fc14bSjoerg
412*4d6fc14bSjoerg#ifdef _LIBCPP_CXX03_LANG
413*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
414*4d6fc14bSjoerg    pair() : first(), second() {}
415*4d6fc14bSjoerg
416*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
417*4d6fc14bSjoerg    pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}
418*4d6fc14bSjoerg
419*4d6fc14bSjoerg    template <class _U1, class _U2>
420*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
421*4d6fc14bSjoerg    pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
422*4d6fc14bSjoerg
423*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
424*4d6fc14bSjoerg    pair& operator=(pair const& __p) {
425*4d6fc14bSjoerg        first = __p.first;
426*4d6fc14bSjoerg        second = __p.second;
427*4d6fc14bSjoerg        return *this;
428*4d6fc14bSjoerg    }
429*4d6fc14bSjoerg#else
430*4d6fc14bSjoerg    template <bool _Val>
431*4d6fc14bSjoerg    using _EnableB _LIBCPP_NODEBUG_TYPE = typename enable_if<_Val, bool>::type;
432*4d6fc14bSjoerg
433*4d6fc14bSjoerg    struct _CheckArgs {
434*4d6fc14bSjoerg      template <int&...>
435*4d6fc14bSjoerg      static constexpr bool __enable_explicit_default() {
436*4d6fc14bSjoerg          return is_default_constructible<_T1>::value
437*4d6fc14bSjoerg              && is_default_constructible<_T2>::value
438*4d6fc14bSjoerg              && !__enable_implicit_default<>();
439*4d6fc14bSjoerg      }
440*4d6fc14bSjoerg
441*4d6fc14bSjoerg      template <int&...>
442*4d6fc14bSjoerg      static constexpr bool __enable_implicit_default() {
443*4d6fc14bSjoerg          return __is_implicitly_default_constructible<_T1>::value
444*4d6fc14bSjoerg              && __is_implicitly_default_constructible<_T2>::value;
445*4d6fc14bSjoerg      }
446*4d6fc14bSjoerg
447*4d6fc14bSjoerg      template <class _U1, class _U2>
448*4d6fc14bSjoerg      static constexpr bool __enable_explicit() {
449*4d6fc14bSjoerg          return is_constructible<first_type, _U1>::value
450*4d6fc14bSjoerg              && is_constructible<second_type, _U2>::value
451*4d6fc14bSjoerg              && (!is_convertible<_U1, first_type>::value
452*4d6fc14bSjoerg                  || !is_convertible<_U2, second_type>::value);
453*4d6fc14bSjoerg      }
454*4d6fc14bSjoerg
455*4d6fc14bSjoerg      template <class _U1, class _U2>
456*4d6fc14bSjoerg      static constexpr bool __enable_implicit() {
457*4d6fc14bSjoerg          return is_constructible<first_type, _U1>::value
458*4d6fc14bSjoerg              && is_constructible<second_type, _U2>::value
459*4d6fc14bSjoerg              && is_convertible<_U1, first_type>::value
460*4d6fc14bSjoerg              && is_convertible<_U2, second_type>::value;
461*4d6fc14bSjoerg      }
462*4d6fc14bSjoerg    };
463*4d6fc14bSjoerg
464*4d6fc14bSjoerg    template <bool _MaybeEnable>
465*4d6fc14bSjoerg    using _CheckArgsDep _LIBCPP_NODEBUG_TYPE = typename conditional<
466*4d6fc14bSjoerg      _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
467*4d6fc14bSjoerg
468*4d6fc14bSjoerg    struct _CheckTupleLikeConstructor {
469*4d6fc14bSjoerg        template <class _Tuple>
470*4d6fc14bSjoerg        static constexpr bool __enable_implicit() {
471*4d6fc14bSjoerg            return __tuple_convertible<_Tuple, pair>::value;
472*4d6fc14bSjoerg        }
473*4d6fc14bSjoerg
474*4d6fc14bSjoerg        template <class _Tuple>
475*4d6fc14bSjoerg        static constexpr bool __enable_explicit() {
476*4d6fc14bSjoerg            return __tuple_constructible<_Tuple, pair>::value
477*4d6fc14bSjoerg               && !__tuple_convertible<_Tuple, pair>::value;
478*4d6fc14bSjoerg        }
479*4d6fc14bSjoerg
480*4d6fc14bSjoerg        template <class _Tuple>
481*4d6fc14bSjoerg        static constexpr bool __enable_assign() {
482*4d6fc14bSjoerg            return __tuple_assignable<_Tuple, pair>::value;
483*4d6fc14bSjoerg        }
484*4d6fc14bSjoerg    };
485*4d6fc14bSjoerg
486*4d6fc14bSjoerg    template <class _Tuple>
487*4d6fc14bSjoerg    using _CheckTLC _LIBCPP_NODEBUG_TYPE = typename conditional<
488*4d6fc14bSjoerg        __tuple_like_with_size<_Tuple, 2>::value
489*4d6fc14bSjoerg            && !is_same<typename decay<_Tuple>::type, pair>::value,
490*4d6fc14bSjoerg        _CheckTupleLikeConstructor,
491*4d6fc14bSjoerg        __check_tuple_constructor_fail
492*4d6fc14bSjoerg    >::type;
493*4d6fc14bSjoerg
494*4d6fc14bSjoerg    template<bool _Dummy = true, _EnableB<
495*4d6fc14bSjoerg            _CheckArgsDep<_Dummy>::__enable_explicit_default()
496*4d6fc14bSjoerg    > = false>
497*4d6fc14bSjoerg    explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
498*4d6fc14bSjoerg    pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
499*4d6fc14bSjoerg                      is_nothrow_default_constructible<second_type>::value)
500*4d6fc14bSjoerg        : first(), second() {}
501*4d6fc14bSjoerg
502*4d6fc14bSjoerg    template<bool _Dummy = true, _EnableB<
503*4d6fc14bSjoerg            _CheckArgsDep<_Dummy>::__enable_implicit_default()
504*4d6fc14bSjoerg    > = false>
505*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
506*4d6fc14bSjoerg    pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
507*4d6fc14bSjoerg                      is_nothrow_default_constructible<second_type>::value)
508*4d6fc14bSjoerg        : first(), second() {}
509*4d6fc14bSjoerg
510*4d6fc14bSjoerg    template <bool _Dummy = true, _EnableB<
511*4d6fc14bSjoerg             _CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>()
512*4d6fc14bSjoerg    > = false>
513*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
514*4d6fc14bSjoerg    explicit pair(_T1 const& __t1, _T2 const& __t2)
515*4d6fc14bSjoerg        _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
516*4d6fc14bSjoerg                   is_nothrow_copy_constructible<second_type>::value)
517*4d6fc14bSjoerg        : first(__t1), second(__t2) {}
518*4d6fc14bSjoerg
519*4d6fc14bSjoerg    template<bool _Dummy = true, _EnableB<
520*4d6fc14bSjoerg            _CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>()
521*4d6fc14bSjoerg    > = false>
522*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
523*4d6fc14bSjoerg    pair(_T1 const& __t1, _T2 const& __t2)
524*4d6fc14bSjoerg        _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
525*4d6fc14bSjoerg                   is_nothrow_copy_constructible<second_type>::value)
526*4d6fc14bSjoerg        : first(__t1), second(__t2) {}
527*4d6fc14bSjoerg
528*4d6fc14bSjoerg    template<class _U1, class _U2, _EnableB<
529*4d6fc14bSjoerg             _CheckArgs::template __enable_explicit<_U1, _U2>()
530*4d6fc14bSjoerg    > = false>
531*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
532*4d6fc14bSjoerg    explicit pair(_U1&& __u1, _U2&& __u2)
533*4d6fc14bSjoerg        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
534*4d6fc14bSjoerg                    is_nothrow_constructible<second_type, _U2>::value))
535*4d6fc14bSjoerg        : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
536*4d6fc14bSjoerg
537*4d6fc14bSjoerg    template<class _U1, class _U2, _EnableB<
538*4d6fc14bSjoerg            _CheckArgs::template __enable_implicit<_U1, _U2>()
539*4d6fc14bSjoerg    > = false>
540*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
541*4d6fc14bSjoerg    pair(_U1&& __u1, _U2&& __u2)
542*4d6fc14bSjoerg        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
543*4d6fc14bSjoerg                    is_nothrow_constructible<second_type, _U2>::value))
544*4d6fc14bSjoerg        : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
545*4d6fc14bSjoerg
546*4d6fc14bSjoerg    template<class _U1, class _U2, _EnableB<
547*4d6fc14bSjoerg            _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
548*4d6fc14bSjoerg    > = false>
549*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
550*4d6fc14bSjoerg    explicit pair(pair<_U1, _U2> const& __p)
551*4d6fc14bSjoerg        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
552*4d6fc14bSjoerg                    is_nothrow_constructible<second_type, _U2 const&>::value))
553*4d6fc14bSjoerg        : first(__p.first), second(__p.second) {}
554*4d6fc14bSjoerg
555*4d6fc14bSjoerg    template<class _U1, class _U2, _EnableB<
556*4d6fc14bSjoerg            _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
557*4d6fc14bSjoerg    > = false>
558*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
559*4d6fc14bSjoerg    pair(pair<_U1, _U2> const& __p)
560*4d6fc14bSjoerg        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
561*4d6fc14bSjoerg                    is_nothrow_constructible<second_type, _U2 const&>::value))
562*4d6fc14bSjoerg        : first(__p.first), second(__p.second) {}
563*4d6fc14bSjoerg
564*4d6fc14bSjoerg    template<class _U1, class _U2, _EnableB<
565*4d6fc14bSjoerg            _CheckArgs::template __enable_explicit<_U1, _U2>()
566*4d6fc14bSjoerg    > = false>
567*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
568*4d6fc14bSjoerg    explicit pair(pair<_U1, _U2>&&__p)
569*4d6fc14bSjoerg        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
570*4d6fc14bSjoerg                    is_nothrow_constructible<second_type, _U2&&>::value))
571*4d6fc14bSjoerg        : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
572*4d6fc14bSjoerg
573*4d6fc14bSjoerg    template<class _U1, class _U2, _EnableB<
574*4d6fc14bSjoerg            _CheckArgs::template __enable_implicit<_U1, _U2>()
575*4d6fc14bSjoerg    > = false>
576*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
577*4d6fc14bSjoerg    pair(pair<_U1, _U2>&& __p)
578*4d6fc14bSjoerg        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
579*4d6fc14bSjoerg                    is_nothrow_constructible<second_type, _U2&&>::value))
580*4d6fc14bSjoerg        : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
581*4d6fc14bSjoerg
582*4d6fc14bSjoerg    template<class _Tuple, _EnableB<
583*4d6fc14bSjoerg            _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
584*4d6fc14bSjoerg    > = false>
585*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
586*4d6fc14bSjoerg    explicit pair(_Tuple&& __p)
587*4d6fc14bSjoerg        : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
588*4d6fc14bSjoerg          second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
589*4d6fc14bSjoerg
590*4d6fc14bSjoerg    template<class _Tuple, _EnableB<
591*4d6fc14bSjoerg            _CheckTLC<_Tuple>::template __enable_implicit<_Tuple>()
592*4d6fc14bSjoerg    > = false>
593*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
594*4d6fc14bSjoerg    pair(_Tuple&& __p)
595*4d6fc14bSjoerg        : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
596*4d6fc14bSjoerg          second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
597*4d6fc14bSjoerg
598*4d6fc14bSjoerg    template <class... _Args1, class... _Args2>
599*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
600*4d6fc14bSjoerg    pair(piecewise_construct_t __pc,
601*4d6fc14bSjoerg         tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
602*4d6fc14bSjoerg        _NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value &&
603*4d6fc14bSjoerg                    is_nothrow_constructible<second_type, _Args2...>::value))
604*4d6fc14bSjoerg        : pair(__pc, __first_args, __second_args,
605*4d6fc14bSjoerg                typename __make_tuple_indices<sizeof...(_Args1)>::type(),
606*4d6fc14bSjoerg                typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
607*4d6fc14bSjoerg
608*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
609*4d6fc14bSjoerg    pair& operator=(typename conditional<
610*4d6fc14bSjoerg                        is_copy_assignable<first_type>::value &&
611*4d6fc14bSjoerg                        is_copy_assignable<second_type>::value,
612*4d6fc14bSjoerg                    pair, __nat>::type const& __p)
613*4d6fc14bSjoerg        _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
614*4d6fc14bSjoerg                   is_nothrow_copy_assignable<second_type>::value)
615*4d6fc14bSjoerg    {
616*4d6fc14bSjoerg        first = __p.first;
617*4d6fc14bSjoerg        second = __p.second;
618*4d6fc14bSjoerg        return *this;
619*4d6fc14bSjoerg    }
620*4d6fc14bSjoerg
621*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
622*4d6fc14bSjoerg    pair& operator=(typename conditional<
623*4d6fc14bSjoerg                        is_move_assignable<first_type>::value &&
624*4d6fc14bSjoerg                        is_move_assignable<second_type>::value,
625*4d6fc14bSjoerg                    pair, __nat>::type&& __p)
626*4d6fc14bSjoerg        _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
627*4d6fc14bSjoerg                   is_nothrow_move_assignable<second_type>::value)
628*4d6fc14bSjoerg    {
629*4d6fc14bSjoerg        first = _VSTD::forward<first_type>(__p.first);
630*4d6fc14bSjoerg        second = _VSTD::forward<second_type>(__p.second);
631*4d6fc14bSjoerg        return *this;
632*4d6fc14bSjoerg    }
633*4d6fc14bSjoerg
634*4d6fc14bSjoerg    template <class _Tuple, _EnableB<
635*4d6fc14bSjoerg            _CheckTLC<_Tuple>::template __enable_assign<_Tuple>()
636*4d6fc14bSjoerg     > = false>
637*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
638*4d6fc14bSjoerg    pair& operator=(_Tuple&& __p) {
639*4d6fc14bSjoerg        first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p));
640*4d6fc14bSjoerg        second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p));
641*4d6fc14bSjoerg        return *this;
642*4d6fc14bSjoerg    }
643*4d6fc14bSjoerg#endif
644*4d6fc14bSjoerg
645*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
646*4d6fc14bSjoerg    void
647*4d6fc14bSjoerg    swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
648*4d6fc14bSjoerg                               __is_nothrow_swappable<second_type>::value)
649*4d6fc14bSjoerg    {
650*4d6fc14bSjoerg        using _VSTD::swap;
651*4d6fc14bSjoerg        swap(first,  __p.first);
652*4d6fc14bSjoerg        swap(second, __p.second);
653*4d6fc14bSjoerg    }
654*4d6fc14bSjoergprivate:
655*4d6fc14bSjoerg
656*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG
657*4d6fc14bSjoerg    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
658*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
659*4d6fc14bSjoerg    pair(piecewise_construct_t,
660*4d6fc14bSjoerg         tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
661*4d6fc14bSjoerg         __tuple_indices<_I1...>, __tuple_indices<_I2...>);
662*4d6fc14bSjoerg#endif
663*4d6fc14bSjoerg};
664*4d6fc14bSjoerg
665*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
666*4d6fc14bSjoergtemplate<class _T1, class _T2>
667*4d6fc14bSjoergpair(_T1, _T2) -> pair<_T1, _T2>;
668*4d6fc14bSjoerg#endif // _LIBCPP_HAS_NO_DEDUCTION_GUIDES
669*4d6fc14bSjoerg
670*4d6fc14bSjoergtemplate <class _T1, class _T2>
671*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
672*4d6fc14bSjoergbool
673*4d6fc14bSjoergoperator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
674*4d6fc14bSjoerg{
675*4d6fc14bSjoerg    return __x.first == __y.first && __x.second == __y.second;
676*4d6fc14bSjoerg}
677*4d6fc14bSjoerg
678*4d6fc14bSjoergtemplate <class _T1, class _T2>
679*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
680*4d6fc14bSjoergbool
681*4d6fc14bSjoergoperator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
682*4d6fc14bSjoerg{
683*4d6fc14bSjoerg    return !(__x == __y);
684*4d6fc14bSjoerg}
685*4d6fc14bSjoerg
686*4d6fc14bSjoergtemplate <class _T1, class _T2>
687*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
688*4d6fc14bSjoergbool
689*4d6fc14bSjoergoperator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
690*4d6fc14bSjoerg{
691*4d6fc14bSjoerg    return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
692*4d6fc14bSjoerg}
693*4d6fc14bSjoerg
694*4d6fc14bSjoergtemplate <class _T1, class _T2>
695*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
696*4d6fc14bSjoergbool
697*4d6fc14bSjoergoperator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
698*4d6fc14bSjoerg{
699*4d6fc14bSjoerg    return __y < __x;
700*4d6fc14bSjoerg}
701*4d6fc14bSjoerg
702*4d6fc14bSjoergtemplate <class _T1, class _T2>
703*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
704*4d6fc14bSjoergbool
705*4d6fc14bSjoergoperator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
706*4d6fc14bSjoerg{
707*4d6fc14bSjoerg    return !(__x < __y);
708*4d6fc14bSjoerg}
709*4d6fc14bSjoerg
710*4d6fc14bSjoergtemplate <class _T1, class _T2>
711*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
712*4d6fc14bSjoergbool
713*4d6fc14bSjoergoperator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
714*4d6fc14bSjoerg{
715*4d6fc14bSjoerg    return !(__y < __x);
716*4d6fc14bSjoerg}
717*4d6fc14bSjoerg
718*4d6fc14bSjoergtemplate <class _T1, class _T2>
719*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
720*4d6fc14bSjoergtypename enable_if
721*4d6fc14bSjoerg<
722*4d6fc14bSjoerg    __is_swappable<_T1>::value &&
723*4d6fc14bSjoerg    __is_swappable<_T2>::value,
724*4d6fc14bSjoerg    void
725*4d6fc14bSjoerg>::type
726*4d6fc14bSjoergswap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
727*4d6fc14bSjoerg                     _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
728*4d6fc14bSjoerg                                 __is_nothrow_swappable<_T2>::value))
729*4d6fc14bSjoerg{
730*4d6fc14bSjoerg    __x.swap(__y);
731*4d6fc14bSjoerg}
732*4d6fc14bSjoerg
733*4d6fc14bSjoergtemplate <class _Tp>
734*4d6fc14bSjoergstruct __unwrap_reference { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };
735*4d6fc14bSjoerg
736*4d6fc14bSjoergtemplate <class _Tp>
737*4d6fc14bSjoergstruct __unwrap_reference<reference_wrapper<_Tp> > { typedef _LIBCPP_NODEBUG_TYPE _Tp& type; };
738*4d6fc14bSjoerg
739*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 17
740*4d6fc14bSjoergtemplate <class _Tp>
741*4d6fc14bSjoergstruct unwrap_reference : __unwrap_reference<_Tp> { };
742*4d6fc14bSjoerg
743*4d6fc14bSjoergtemplate <class _Tp>
744*4d6fc14bSjoergstruct unwrap_ref_decay : unwrap_reference<typename decay<_Tp>::type> { };
745*4d6fc14bSjoerg#endif // > C++17
746*4d6fc14bSjoerg
747*4d6fc14bSjoergtemplate <class _Tp>
748*4d6fc14bSjoergstruct __unwrap_ref_decay
749*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 17
750*4d6fc14bSjoerg    : unwrap_ref_decay<_Tp>
751*4d6fc14bSjoerg#else
752*4d6fc14bSjoerg    : __unwrap_reference<typename decay<_Tp>::type>
753*4d6fc14bSjoerg#endif
754*4d6fc14bSjoerg{ };
755*4d6fc14bSjoerg
756*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG
757*4d6fc14bSjoerg
758*4d6fc14bSjoergtemplate <class _T1, class _T2>
759*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
760*4d6fc14bSjoergpair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
761*4d6fc14bSjoergmake_pair(_T1&& __t1, _T2&& __t2)
762*4d6fc14bSjoerg{
763*4d6fc14bSjoerg    return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
764*4d6fc14bSjoerg               (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
765*4d6fc14bSjoerg}
766*4d6fc14bSjoerg
767*4d6fc14bSjoerg#else  // _LIBCPP_CXX03_LANG
768*4d6fc14bSjoerg
769*4d6fc14bSjoergtemplate <class _T1, class _T2>
770*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
771*4d6fc14bSjoergpair<_T1,_T2>
772*4d6fc14bSjoergmake_pair(_T1 __x, _T2 __y)
773*4d6fc14bSjoerg{
774*4d6fc14bSjoerg    return pair<_T1, _T2>(__x, __y);
775*4d6fc14bSjoerg}
776*4d6fc14bSjoerg
777*4d6fc14bSjoerg#endif // _LIBCPP_CXX03_LANG
778*4d6fc14bSjoerg
779*4d6fc14bSjoergtemplate <class _T1, class _T2>
780*4d6fc14bSjoerg  struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
781*4d6fc14bSjoerg    : public integral_constant<size_t, 2> {};
782*4d6fc14bSjoerg
783*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2>
784*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
785*4d6fc14bSjoerg{
786*4d6fc14bSjoerg    static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
787*4d6fc14bSjoerg};
788*4d6fc14bSjoerg
789*4d6fc14bSjoergtemplate <class _T1, class _T2>
790*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
791*4d6fc14bSjoerg{
792*4d6fc14bSjoerg    typedef _LIBCPP_NODEBUG_TYPE _T1 type;
793*4d6fc14bSjoerg};
794*4d6fc14bSjoerg
795*4d6fc14bSjoergtemplate <class _T1, class _T2>
796*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
797*4d6fc14bSjoerg{
798*4d6fc14bSjoerg    typedef _LIBCPP_NODEBUG_TYPE _T2 type;
799*4d6fc14bSjoerg};
800*4d6fc14bSjoerg
801*4d6fc14bSjoergtemplate <size_t _Ip> struct __get_pair;
802*4d6fc14bSjoerg
803*4d6fc14bSjoergtemplate <>
804*4d6fc14bSjoergstruct __get_pair<0>
805*4d6fc14bSjoerg{
806*4d6fc14bSjoerg    template <class _T1, class _T2>
807*4d6fc14bSjoerg    static
808*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
809*4d6fc14bSjoerg    _T1&
810*4d6fc14bSjoerg    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
811*4d6fc14bSjoerg
812*4d6fc14bSjoerg    template <class _T1, class _T2>
813*4d6fc14bSjoerg    static
814*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
815*4d6fc14bSjoerg    const _T1&
816*4d6fc14bSjoerg    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
817*4d6fc14bSjoerg
818*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG
819*4d6fc14bSjoerg    template <class _T1, class _T2>
820*4d6fc14bSjoerg    static
821*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
822*4d6fc14bSjoerg    _T1&&
823*4d6fc14bSjoerg    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
824*4d6fc14bSjoerg
825*4d6fc14bSjoerg    template <class _T1, class _T2>
826*4d6fc14bSjoerg    static
827*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
828*4d6fc14bSjoerg    const _T1&&
829*4d6fc14bSjoerg    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);}
830*4d6fc14bSjoerg#endif // _LIBCPP_CXX03_LANG
831*4d6fc14bSjoerg};
832*4d6fc14bSjoerg
833*4d6fc14bSjoergtemplate <>
834*4d6fc14bSjoergstruct __get_pair<1>
835*4d6fc14bSjoerg{
836*4d6fc14bSjoerg    template <class _T1, class _T2>
837*4d6fc14bSjoerg    static
838*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
839*4d6fc14bSjoerg    _T2&
840*4d6fc14bSjoerg    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
841*4d6fc14bSjoerg
842*4d6fc14bSjoerg    template <class _T1, class _T2>
843*4d6fc14bSjoerg    static
844*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
845*4d6fc14bSjoerg    const _T2&
846*4d6fc14bSjoerg    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
847*4d6fc14bSjoerg
848*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG
849*4d6fc14bSjoerg    template <class _T1, class _T2>
850*4d6fc14bSjoerg    static
851*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
852*4d6fc14bSjoerg    _T2&&
853*4d6fc14bSjoerg    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
854*4d6fc14bSjoerg
855*4d6fc14bSjoerg    template <class _T1, class _T2>
856*4d6fc14bSjoerg    static
857*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
858*4d6fc14bSjoerg    const _T2&&
859*4d6fc14bSjoerg    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);}
860*4d6fc14bSjoerg#endif // _LIBCPP_CXX03_LANG
861*4d6fc14bSjoerg};
862*4d6fc14bSjoerg
863*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2>
864*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
865*4d6fc14bSjoergtypename tuple_element<_Ip, pair<_T1, _T2> >::type&
866*4d6fc14bSjoergget(pair<_T1, _T2>& __p) _NOEXCEPT
867*4d6fc14bSjoerg{
868*4d6fc14bSjoerg    return __get_pair<_Ip>::get(__p);
869*4d6fc14bSjoerg}
870*4d6fc14bSjoerg
871*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2>
872*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
873*4d6fc14bSjoergconst typename tuple_element<_Ip, pair<_T1, _T2> >::type&
874*4d6fc14bSjoergget(const pair<_T1, _T2>& __p) _NOEXCEPT
875*4d6fc14bSjoerg{
876*4d6fc14bSjoerg    return __get_pair<_Ip>::get(__p);
877*4d6fc14bSjoerg}
878*4d6fc14bSjoerg
879*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG
880*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2>
881*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
882*4d6fc14bSjoergtypename tuple_element<_Ip, pair<_T1, _T2> >::type&&
883*4d6fc14bSjoergget(pair<_T1, _T2>&& __p) _NOEXCEPT
884*4d6fc14bSjoerg{
885*4d6fc14bSjoerg    return __get_pair<_Ip>::get(_VSTD::move(__p));
886*4d6fc14bSjoerg}
887*4d6fc14bSjoerg
888*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2>
889*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
890*4d6fc14bSjoergconst typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
891*4d6fc14bSjoergget(const pair<_T1, _T2>&& __p) _NOEXCEPT
892*4d6fc14bSjoerg{
893*4d6fc14bSjoerg    return __get_pair<_Ip>::get(_VSTD::move(__p));
894*4d6fc14bSjoerg}
895*4d6fc14bSjoerg#endif // _LIBCPP_CXX03_LANG
896*4d6fc14bSjoerg
897*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 11
898*4d6fc14bSjoergtemplate <class _T1, class _T2>
899*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
900*4d6fc14bSjoergconstexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
901*4d6fc14bSjoerg{
902*4d6fc14bSjoerg    return __get_pair<0>::get(__p);
903*4d6fc14bSjoerg}
904*4d6fc14bSjoerg
905*4d6fc14bSjoergtemplate <class _T1, class _T2>
906*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
907*4d6fc14bSjoergconstexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
908*4d6fc14bSjoerg{
909*4d6fc14bSjoerg    return __get_pair<0>::get(__p);
910*4d6fc14bSjoerg}
911*4d6fc14bSjoerg
912*4d6fc14bSjoergtemplate <class _T1, class _T2>
913*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
914*4d6fc14bSjoergconstexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
915*4d6fc14bSjoerg{
916*4d6fc14bSjoerg    return __get_pair<0>::get(_VSTD::move(__p));
917*4d6fc14bSjoerg}
918*4d6fc14bSjoerg
919*4d6fc14bSjoergtemplate <class _T1, class _T2>
920*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
921*4d6fc14bSjoergconstexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT
922*4d6fc14bSjoerg{
923*4d6fc14bSjoerg    return __get_pair<0>::get(_VSTD::move(__p));
924*4d6fc14bSjoerg}
925*4d6fc14bSjoerg
926*4d6fc14bSjoergtemplate <class _T1, class _T2>
927*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
928*4d6fc14bSjoergconstexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
929*4d6fc14bSjoerg{
930*4d6fc14bSjoerg    return __get_pair<1>::get(__p);
931*4d6fc14bSjoerg}
932*4d6fc14bSjoerg
933*4d6fc14bSjoergtemplate <class _T1, class _T2>
934*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
935*4d6fc14bSjoergconstexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
936*4d6fc14bSjoerg{
937*4d6fc14bSjoerg    return __get_pair<1>::get(__p);
938*4d6fc14bSjoerg}
939*4d6fc14bSjoerg
940*4d6fc14bSjoergtemplate <class _T1, class _T2>
941*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
942*4d6fc14bSjoergconstexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
943*4d6fc14bSjoerg{
944*4d6fc14bSjoerg    return __get_pair<1>::get(_VSTD::move(__p));
945*4d6fc14bSjoerg}
946*4d6fc14bSjoerg
947*4d6fc14bSjoergtemplate <class _T1, class _T2>
948*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
949*4d6fc14bSjoergconstexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
950*4d6fc14bSjoerg{
951*4d6fc14bSjoerg    return __get_pair<1>::get(_VSTD::move(__p));
952*4d6fc14bSjoerg}
953*4d6fc14bSjoerg
954*4d6fc14bSjoerg#endif
955*4d6fc14bSjoerg
956*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 11
957*4d6fc14bSjoerg
958*4d6fc14bSjoergtemplate<class _Tp, _Tp... _Ip>
959*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS integer_sequence
960*4d6fc14bSjoerg{
961*4d6fc14bSjoerg    typedef _Tp value_type;
962*4d6fc14bSjoerg    static_assert( is_integral<_Tp>::value,
963*4d6fc14bSjoerg                  "std::integer_sequence can only be instantiated with an integral type" );
964*4d6fc14bSjoerg    static
965*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
966*4d6fc14bSjoerg    constexpr
967*4d6fc14bSjoerg    size_t
968*4d6fc14bSjoerg    size() noexcept { return sizeof...(_Ip); }
969*4d6fc14bSjoerg};
970*4d6fc14bSjoerg
971*4d6fc14bSjoergtemplate<size_t... _Ip>
972*4d6fc14bSjoerg    using index_sequence = integer_sequence<size_t, _Ip...>;
973*4d6fc14bSjoerg
974*4d6fc14bSjoerg#if __has_builtin(__make_integer_seq) && !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
975*4d6fc14bSjoerg
976*4d6fc14bSjoergtemplate <class _Tp, _Tp _Ep>
977*4d6fc14bSjoergusing __make_integer_sequence _LIBCPP_NODEBUG_TYPE = __make_integer_seq<integer_sequence, _Tp, _Ep>;
978*4d6fc14bSjoerg
979*4d6fc14bSjoerg#else
980*4d6fc14bSjoerg
981*4d6fc14bSjoergtemplate<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked _LIBCPP_NODEBUG_TYPE  =
982*4d6fc14bSjoerg  typename __detail::__make<_Np>::type::template __convert<integer_sequence, _Tp>;
983*4d6fc14bSjoerg
984*4d6fc14bSjoergtemplate <class _Tp, _Tp _Ep>
985*4d6fc14bSjoergstruct __make_integer_sequence_checked
986*4d6fc14bSjoerg{
987*4d6fc14bSjoerg    static_assert(is_integral<_Tp>::value,
988*4d6fc14bSjoerg                  "std::make_integer_sequence can only be instantiated with an integral type" );
989*4d6fc14bSjoerg    static_assert(0 <= _Ep, "std::make_integer_sequence must have a non-negative sequence length");
990*4d6fc14bSjoerg    // Workaround GCC bug by preventing bad installations when 0 <= _Ep
991*4d6fc14bSjoerg    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68929
992*4d6fc14bSjoerg    typedef _LIBCPP_NODEBUG_TYPE  __make_integer_sequence_unchecked<_Tp, 0 <= _Ep ? _Ep : 0> type;
993*4d6fc14bSjoerg};
994*4d6fc14bSjoerg
995*4d6fc14bSjoergtemplate <class _Tp, _Tp _Ep>
996*4d6fc14bSjoergusing __make_integer_sequence _LIBCPP_NODEBUG_TYPE = typename __make_integer_sequence_checked<_Tp, _Ep>::type;
997*4d6fc14bSjoerg
998*4d6fc14bSjoerg#endif
999*4d6fc14bSjoerg
1000*4d6fc14bSjoergtemplate<class _Tp, _Tp _Np>
1001*4d6fc14bSjoerg    using make_integer_sequence = __make_integer_sequence<_Tp, _Np>;
1002*4d6fc14bSjoerg
1003*4d6fc14bSjoergtemplate<size_t _Np>
1004*4d6fc14bSjoerg    using make_index_sequence = make_integer_sequence<size_t, _Np>;
1005*4d6fc14bSjoerg
1006*4d6fc14bSjoergtemplate<class... _Tp>
1007*4d6fc14bSjoerg    using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
1008*4d6fc14bSjoerg
1009*4d6fc14bSjoerg#endif // _LIBCPP_STD_VER > 11
1010*4d6fc14bSjoerg
1011*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 11
1012*4d6fc14bSjoergtemplate<class _T1, class _T2 = _T1>
1013*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1014*4d6fc14bSjoerg_T1 exchange(_T1& __obj, _T2 && __new_value)
1015*4d6fc14bSjoerg{
1016*4d6fc14bSjoerg    _T1 __old_value = _VSTD::move(__obj);
1017*4d6fc14bSjoerg    __obj = _VSTD::forward<_T2>(__new_value);
1018*4d6fc14bSjoerg    return __old_value;
1019*4d6fc14bSjoerg}
1020*4d6fc14bSjoerg#endif // _LIBCPP_STD_VER > 11
1021*4d6fc14bSjoerg
1022*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 14
1023*4d6fc14bSjoerg
1024*4d6fc14bSjoergstruct _LIBCPP_TYPE_VIS in_place_t {
1025*4d6fc14bSjoerg    explicit in_place_t() = default;
1026*4d6fc14bSjoerg};
1027*4d6fc14bSjoerg_LIBCPP_INLINE_VAR constexpr in_place_t in_place{};
1028*4d6fc14bSjoerg
1029*4d6fc14bSjoergtemplate <class _Tp>
1030*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS in_place_type_t {
1031*4d6fc14bSjoerg    explicit in_place_type_t() = default;
1032*4d6fc14bSjoerg};
1033*4d6fc14bSjoergtemplate <class _Tp>
1034*4d6fc14bSjoerg_LIBCPP_INLINE_VAR constexpr in_place_type_t<_Tp> in_place_type{};
1035*4d6fc14bSjoerg
1036*4d6fc14bSjoergtemplate <size_t _Idx>
1037*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS in_place_index_t {
1038*4d6fc14bSjoerg    explicit in_place_index_t() = default;
1039*4d6fc14bSjoerg};
1040*4d6fc14bSjoergtemplate <size_t _Idx>
1041*4d6fc14bSjoerg_LIBCPP_INLINE_VAR constexpr in_place_index_t<_Idx> in_place_index{};
1042*4d6fc14bSjoerg
1043*4d6fc14bSjoergtemplate <class _Tp> struct __is_inplace_type_imp : false_type {};
1044*4d6fc14bSjoergtemplate <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {};
1045*4d6fc14bSjoerg
1046*4d6fc14bSjoergtemplate <class _Tp>
1047*4d6fc14bSjoergusing __is_inplace_type = __is_inplace_type_imp<__uncvref_t<_Tp>>;
1048*4d6fc14bSjoerg
1049*4d6fc14bSjoergtemplate <class _Tp> struct __is_inplace_index_imp : false_type {};
1050*4d6fc14bSjoergtemplate <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {};
1051*4d6fc14bSjoerg
1052*4d6fc14bSjoergtemplate <class _Tp>
1053*4d6fc14bSjoergusing __is_inplace_index = __is_inplace_index_imp<__uncvref_t<_Tp>>;
1054*4d6fc14bSjoerg
1055*4d6fc14bSjoerg#endif // _LIBCPP_STD_VER > 14
1056*4d6fc14bSjoerg
1057*4d6fc14bSjoergtemplate <class _Arg, class _Result>
1058*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS unary_function
1059*4d6fc14bSjoerg{
1060*4d6fc14bSjoerg    typedef _Arg    argument_type;
1061*4d6fc14bSjoerg    typedef _Result result_type;
1062*4d6fc14bSjoerg};
1063*4d6fc14bSjoerg
1064*4d6fc14bSjoergtemplate <class _Size>
1065*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY
1066*4d6fc14bSjoerg_Size
1067*4d6fc14bSjoerg__loadword(const void* __p)
1068*4d6fc14bSjoerg{
1069*4d6fc14bSjoerg    _Size __r;
1070*4d6fc14bSjoerg    _VSTD::memcpy(&__r, __p, sizeof(__r));
1071*4d6fc14bSjoerg    return __r;
1072*4d6fc14bSjoerg}
1073*4d6fc14bSjoerg
1074*4d6fc14bSjoerg// We use murmur2 when size_t is 32 bits, and cityhash64 when size_t
1075*4d6fc14bSjoerg// is 64 bits.  This is because cityhash64 uses 64bit x 64bit
1076*4d6fc14bSjoerg// multiplication, which can be very slow on 32-bit systems.
1077*4d6fc14bSjoergtemplate <class _Size, size_t = sizeof(_Size)*__CHAR_BIT__>
1078*4d6fc14bSjoergstruct __murmur2_or_cityhash;
1079*4d6fc14bSjoerg
1080*4d6fc14bSjoergtemplate <class _Size>
1081*4d6fc14bSjoergstruct __murmur2_or_cityhash<_Size, 32>
1082*4d6fc14bSjoerg{
1083*4d6fc14bSjoerg    inline _Size operator()(const void* __key, _Size __len)
1084*4d6fc14bSjoerg         _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK;
1085*4d6fc14bSjoerg};
1086*4d6fc14bSjoerg
1087*4d6fc14bSjoerg// murmur2
1088*4d6fc14bSjoergtemplate <class _Size>
1089*4d6fc14bSjoerg_Size
1090*4d6fc14bSjoerg__murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len)
1091*4d6fc14bSjoerg{
1092*4d6fc14bSjoerg    const _Size __m = 0x5bd1e995;
1093*4d6fc14bSjoerg    const _Size __r = 24;
1094*4d6fc14bSjoerg    _Size __h = __len;
1095*4d6fc14bSjoerg    const unsigned char* __data = static_cast<const unsigned char*>(__key);
1096*4d6fc14bSjoerg    for (; __len >= 4; __data += 4, __len -= 4)
1097*4d6fc14bSjoerg    {
1098*4d6fc14bSjoerg        _Size __k = __loadword<_Size>(__data);
1099*4d6fc14bSjoerg        __k *= __m;
1100*4d6fc14bSjoerg        __k ^= __k >> __r;
1101*4d6fc14bSjoerg        __k *= __m;
1102*4d6fc14bSjoerg        __h *= __m;
1103*4d6fc14bSjoerg        __h ^= __k;
1104*4d6fc14bSjoerg    }
1105*4d6fc14bSjoerg    switch (__len)
1106*4d6fc14bSjoerg    {
1107*4d6fc14bSjoerg    case 3:
1108*4d6fc14bSjoerg        __h ^= __data[2] << 16;
1109*4d6fc14bSjoerg        _LIBCPP_FALLTHROUGH();
1110*4d6fc14bSjoerg    case 2:
1111*4d6fc14bSjoerg        __h ^= __data[1] << 8;
1112*4d6fc14bSjoerg        _LIBCPP_FALLTHROUGH();
1113*4d6fc14bSjoerg    case 1:
1114*4d6fc14bSjoerg        __h ^= __data[0];
1115*4d6fc14bSjoerg        __h *= __m;
1116*4d6fc14bSjoerg    }
1117*4d6fc14bSjoerg    __h ^= __h >> 13;
1118*4d6fc14bSjoerg    __h *= __m;
1119*4d6fc14bSjoerg    __h ^= __h >> 15;
1120*4d6fc14bSjoerg    return __h;
1121*4d6fc14bSjoerg}
1122*4d6fc14bSjoerg
1123*4d6fc14bSjoergtemplate <class _Size>
1124*4d6fc14bSjoergstruct __murmur2_or_cityhash<_Size, 64>
1125*4d6fc14bSjoerg{
1126*4d6fc14bSjoerg    inline _Size operator()(const void* __key, _Size __len)  _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK;
1127*4d6fc14bSjoerg
1128*4d6fc14bSjoerg private:
1129*4d6fc14bSjoerg  // Some primes between 2^63 and 2^64.
1130*4d6fc14bSjoerg  static const _Size __k0 = 0xc3a5c85c97cb3127ULL;
1131*4d6fc14bSjoerg  static const _Size __k1 = 0xb492b66fbe98f273ULL;
1132*4d6fc14bSjoerg  static const _Size __k2 = 0x9ae16a3b2f90404fULL;
1133*4d6fc14bSjoerg  static const _Size __k3 = 0xc949d7c7509e6557ULL;
1134*4d6fc14bSjoerg
1135*4d6fc14bSjoerg  static _Size __rotate(_Size __val, int __shift) {
1136*4d6fc14bSjoerg    return __shift == 0 ? __val : ((__val >> __shift) | (__val << (64 - __shift)));
1137*4d6fc14bSjoerg  }
1138*4d6fc14bSjoerg
1139*4d6fc14bSjoerg  static _Size __rotate_by_at_least_1(_Size __val, int __shift) {
1140*4d6fc14bSjoerg    return (__val >> __shift) | (__val << (64 - __shift));
1141*4d6fc14bSjoerg  }
1142*4d6fc14bSjoerg
1143*4d6fc14bSjoerg  static _Size __shift_mix(_Size __val) {
1144*4d6fc14bSjoerg    return __val ^ (__val >> 47);
1145*4d6fc14bSjoerg  }
1146*4d6fc14bSjoerg
1147*4d6fc14bSjoerg  static _Size __hash_len_16(_Size __u, _Size __v)
1148*4d6fc14bSjoerg     _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
1149*4d6fc14bSjoerg  {
1150*4d6fc14bSjoerg    const _Size __mul = 0x9ddfea08eb382d69ULL;
1151*4d6fc14bSjoerg    _Size __a = (__u ^ __v) * __mul;
1152*4d6fc14bSjoerg    __a ^= (__a >> 47);
1153*4d6fc14bSjoerg    _Size __b = (__v ^ __a) * __mul;
1154*4d6fc14bSjoerg    __b ^= (__b >> 47);
1155*4d6fc14bSjoerg    __b *= __mul;
1156*4d6fc14bSjoerg    return __b;
1157*4d6fc14bSjoerg  }
1158*4d6fc14bSjoerg
1159*4d6fc14bSjoerg  static _Size __hash_len_0_to_16(const char* __s, _Size __len)
1160*4d6fc14bSjoerg     _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
1161*4d6fc14bSjoerg  {
1162*4d6fc14bSjoerg    if (__len > 8) {
1163*4d6fc14bSjoerg      const _Size __a = __loadword<_Size>(__s);
1164*4d6fc14bSjoerg      const _Size __b = __loadword<_Size>(__s + __len - 8);
1165*4d6fc14bSjoerg      return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b;
1166*4d6fc14bSjoerg    }
1167*4d6fc14bSjoerg    if (__len >= 4) {
1168*4d6fc14bSjoerg      const uint32_t __a = __loadword<uint32_t>(__s);
1169*4d6fc14bSjoerg      const uint32_t __b = __loadword<uint32_t>(__s + __len - 4);
1170*4d6fc14bSjoerg      return __hash_len_16(__len + (__a << 3), __b);
1171*4d6fc14bSjoerg    }
1172*4d6fc14bSjoerg    if (__len > 0) {
1173*4d6fc14bSjoerg      const unsigned char __a = __s[0];
1174*4d6fc14bSjoerg      const unsigned char __b = __s[__len >> 1];
1175*4d6fc14bSjoerg      const unsigned char __c = __s[__len - 1];
1176*4d6fc14bSjoerg      const uint32_t __y = static_cast<uint32_t>(__a) +
1177*4d6fc14bSjoerg                           (static_cast<uint32_t>(__b) << 8);
1178*4d6fc14bSjoerg      const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2);
1179*4d6fc14bSjoerg      return __shift_mix(__y * __k2 ^ __z * __k3) * __k2;
1180*4d6fc14bSjoerg    }
1181*4d6fc14bSjoerg    return __k2;
1182*4d6fc14bSjoerg  }
1183*4d6fc14bSjoerg
1184*4d6fc14bSjoerg  static _Size __hash_len_17_to_32(const char *__s, _Size __len)
1185*4d6fc14bSjoerg     _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
1186*4d6fc14bSjoerg  {
1187*4d6fc14bSjoerg    const _Size __a = __loadword<_Size>(__s) * __k1;
1188*4d6fc14bSjoerg    const _Size __b = __loadword<_Size>(__s + 8);
1189*4d6fc14bSjoerg    const _Size __c = __loadword<_Size>(__s + __len - 8) * __k2;
1190*4d6fc14bSjoerg    const _Size __d = __loadword<_Size>(__s + __len - 16) * __k0;
1191*4d6fc14bSjoerg    return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d,
1192*4d6fc14bSjoerg                         __a + __rotate(__b ^ __k3, 20) - __c + __len);
1193*4d6fc14bSjoerg  }
1194*4d6fc14bSjoerg
1195*4d6fc14bSjoerg  // Return a 16-byte hash for 48 bytes.  Quick and dirty.
1196*4d6fc14bSjoerg  // Callers do best to use "random-looking" values for a and b.
1197*4d6fc14bSjoerg  static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
1198*4d6fc14bSjoerg      _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b)
1199*4d6fc14bSjoerg        _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
1200*4d6fc14bSjoerg  {
1201*4d6fc14bSjoerg    __a += __w;
1202*4d6fc14bSjoerg    __b = __rotate(__b + __a + __z, 21);
1203*4d6fc14bSjoerg    const _Size __c = __a;
1204*4d6fc14bSjoerg    __a += __x;
1205*4d6fc14bSjoerg    __a += __y;
1206*4d6fc14bSjoerg    __b += __rotate(__a, 44);
1207*4d6fc14bSjoerg    return pair<_Size, _Size>(__a + __z, __b + __c);
1208*4d6fc14bSjoerg  }
1209*4d6fc14bSjoerg
1210*4d6fc14bSjoerg  // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
1211*4d6fc14bSjoerg  static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
1212*4d6fc14bSjoerg      const char* __s, _Size __a, _Size __b)
1213*4d6fc14bSjoerg    _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
1214*4d6fc14bSjoerg  {
1215*4d6fc14bSjoerg    return __weak_hash_len_32_with_seeds(__loadword<_Size>(__s),
1216*4d6fc14bSjoerg                                         __loadword<_Size>(__s + 8),
1217*4d6fc14bSjoerg                                         __loadword<_Size>(__s + 16),
1218*4d6fc14bSjoerg                                         __loadword<_Size>(__s + 24),
1219*4d6fc14bSjoerg                                         __a,
1220*4d6fc14bSjoerg                                         __b);
1221*4d6fc14bSjoerg  }
1222*4d6fc14bSjoerg
1223*4d6fc14bSjoerg  // Return an 8-byte hash for 33 to 64 bytes.
1224*4d6fc14bSjoerg  static _Size __hash_len_33_to_64(const char *__s, size_t __len)
1225*4d6fc14bSjoerg    _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
1226*4d6fc14bSjoerg  {
1227*4d6fc14bSjoerg    _Size __z = __loadword<_Size>(__s + 24);
1228*4d6fc14bSjoerg    _Size __a = __loadword<_Size>(__s) +
1229*4d6fc14bSjoerg                (__len + __loadword<_Size>(__s + __len - 16)) * __k0;
1230*4d6fc14bSjoerg    _Size __b = __rotate(__a + __z, 52);
1231*4d6fc14bSjoerg    _Size __c = __rotate(__a, 37);
1232*4d6fc14bSjoerg    __a += __loadword<_Size>(__s + 8);
1233*4d6fc14bSjoerg    __c += __rotate(__a, 7);
1234*4d6fc14bSjoerg    __a += __loadword<_Size>(__s + 16);
1235*4d6fc14bSjoerg    _Size __vf = __a + __z;
1236*4d6fc14bSjoerg    _Size __vs = __b + __rotate(__a, 31) + __c;
1237*4d6fc14bSjoerg    __a = __loadword<_Size>(__s + 16) + __loadword<_Size>(__s + __len - 32);
1238*4d6fc14bSjoerg    __z += __loadword<_Size>(__s + __len - 8);
1239*4d6fc14bSjoerg    __b = __rotate(__a + __z, 52);
1240*4d6fc14bSjoerg    __c = __rotate(__a, 37);
1241*4d6fc14bSjoerg    __a += __loadword<_Size>(__s + __len - 24);
1242*4d6fc14bSjoerg    __c += __rotate(__a, 7);
1243*4d6fc14bSjoerg    __a += __loadword<_Size>(__s + __len - 16);
1244*4d6fc14bSjoerg    _Size __wf = __a + __z;
1245*4d6fc14bSjoerg    _Size __ws = __b + __rotate(__a, 31) + __c;
1246*4d6fc14bSjoerg    _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0);
1247*4d6fc14bSjoerg    return __shift_mix(__r * __k0 + __vs) * __k2;
1248*4d6fc14bSjoerg  }
1249*4d6fc14bSjoerg};
1250*4d6fc14bSjoerg
1251*4d6fc14bSjoerg// cityhash64
1252*4d6fc14bSjoergtemplate <class _Size>
1253*4d6fc14bSjoerg_Size
1254*4d6fc14bSjoerg__murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len)
1255*4d6fc14bSjoerg{
1256*4d6fc14bSjoerg  const char* __s = static_cast<const char*>(__key);
1257*4d6fc14bSjoerg  if (__len <= 32) {
1258*4d6fc14bSjoerg    if (__len <= 16) {
1259*4d6fc14bSjoerg      return __hash_len_0_to_16(__s, __len);
1260*4d6fc14bSjoerg    } else {
1261*4d6fc14bSjoerg      return __hash_len_17_to_32(__s, __len);
1262*4d6fc14bSjoerg    }
1263*4d6fc14bSjoerg  } else if (__len <= 64) {
1264*4d6fc14bSjoerg    return __hash_len_33_to_64(__s, __len);
1265*4d6fc14bSjoerg  }
1266*4d6fc14bSjoerg
1267*4d6fc14bSjoerg  // For strings over 64 bytes we hash the end first, and then as we
1268*4d6fc14bSjoerg  // loop we keep 56 bytes of state: v, w, x, y, and z.
1269*4d6fc14bSjoerg  _Size __x = __loadword<_Size>(__s + __len - 40);
1270*4d6fc14bSjoerg  _Size __y = __loadword<_Size>(__s + __len - 16) +
1271*4d6fc14bSjoerg              __loadword<_Size>(__s + __len - 56);
1272*4d6fc14bSjoerg  _Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len,
1273*4d6fc14bSjoerg                          __loadword<_Size>(__s + __len - 24));
1274*4d6fc14bSjoerg  pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z);
1275*4d6fc14bSjoerg  pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x);
1276*4d6fc14bSjoerg  __x = __x * __k1 + __loadword<_Size>(__s);
1277*4d6fc14bSjoerg
1278*4d6fc14bSjoerg  // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
1279*4d6fc14bSjoerg  __len = (__len - 1) & ~static_cast<_Size>(63);
1280*4d6fc14bSjoerg  do {
1281*4d6fc14bSjoerg    __x = __rotate(__x + __y + __v.first + __loadword<_Size>(__s + 8), 37) * __k1;
1282*4d6fc14bSjoerg    __y = __rotate(__y + __v.second + __loadword<_Size>(__s + 48), 42) * __k1;
1283*4d6fc14bSjoerg    __x ^= __w.second;
1284*4d6fc14bSjoerg    __y += __v.first + __loadword<_Size>(__s + 40);
1285*4d6fc14bSjoerg    __z = __rotate(__z + __w.first, 33) * __k1;
1286*4d6fc14bSjoerg    __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first);
1287*4d6fc14bSjoerg    __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second,
1288*4d6fc14bSjoerg                                        __y + __loadword<_Size>(__s + 16));
1289*4d6fc14bSjoerg    _VSTD::swap(__z, __x);
1290*4d6fc14bSjoerg    __s += 64;
1291*4d6fc14bSjoerg    __len -= 64;
1292*4d6fc14bSjoerg  } while (__len != 0);
1293*4d6fc14bSjoerg  return __hash_len_16(
1294*4d6fc14bSjoerg      __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z,
1295*4d6fc14bSjoerg      __hash_len_16(__v.second, __w.second) + __x);
1296*4d6fc14bSjoerg}
1297*4d6fc14bSjoerg
1298*4d6fc14bSjoergtemplate <class _Tp, size_t = sizeof(_Tp) / sizeof(size_t)>
1299*4d6fc14bSjoergstruct __scalar_hash;
1300*4d6fc14bSjoerg
1301*4d6fc14bSjoergtemplate <class _Tp>
1302*4d6fc14bSjoergstruct __scalar_hash<_Tp, 0>
1303*4d6fc14bSjoerg    : public unary_function<_Tp, size_t>
1304*4d6fc14bSjoerg{
1305*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1306*4d6fc14bSjoerg    size_t operator()(_Tp __v) const _NOEXCEPT
1307*4d6fc14bSjoerg    {
1308*4d6fc14bSjoerg        union
1309*4d6fc14bSjoerg        {
1310*4d6fc14bSjoerg            _Tp    __t;
1311*4d6fc14bSjoerg            size_t __a;
1312*4d6fc14bSjoerg        } __u;
1313*4d6fc14bSjoerg        __u.__a = 0;
1314*4d6fc14bSjoerg        __u.__t = __v;
1315*4d6fc14bSjoerg        return __u.__a;
1316*4d6fc14bSjoerg    }
1317*4d6fc14bSjoerg};
1318*4d6fc14bSjoerg
1319*4d6fc14bSjoergtemplate <class _Tp>
1320*4d6fc14bSjoergstruct __scalar_hash<_Tp, 1>
1321*4d6fc14bSjoerg    : public unary_function<_Tp, size_t>
1322*4d6fc14bSjoerg{
1323*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1324*4d6fc14bSjoerg    size_t operator()(_Tp __v) const _NOEXCEPT
1325*4d6fc14bSjoerg    {
1326*4d6fc14bSjoerg        union
1327*4d6fc14bSjoerg        {
1328*4d6fc14bSjoerg            _Tp    __t;
1329*4d6fc14bSjoerg            size_t __a;
1330*4d6fc14bSjoerg        } __u;
1331*4d6fc14bSjoerg        __u.__t = __v;
1332*4d6fc14bSjoerg        return __u.__a;
1333*4d6fc14bSjoerg    }
1334*4d6fc14bSjoerg};
1335*4d6fc14bSjoerg
1336*4d6fc14bSjoergtemplate <class _Tp>
1337*4d6fc14bSjoergstruct __scalar_hash<_Tp, 2>
1338*4d6fc14bSjoerg    : public unary_function<_Tp, size_t>
1339*4d6fc14bSjoerg{
1340*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1341*4d6fc14bSjoerg    size_t operator()(_Tp __v) const _NOEXCEPT
1342*4d6fc14bSjoerg    {
1343*4d6fc14bSjoerg        union
1344*4d6fc14bSjoerg        {
1345*4d6fc14bSjoerg            _Tp __t;
1346*4d6fc14bSjoerg            struct
1347*4d6fc14bSjoerg            {
1348*4d6fc14bSjoerg                size_t __a;
1349*4d6fc14bSjoerg                size_t __b;
1350*4d6fc14bSjoerg            } __s;
1351*4d6fc14bSjoerg        } __u;
1352*4d6fc14bSjoerg        __u.__t = __v;
1353*4d6fc14bSjoerg        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
1354*4d6fc14bSjoerg    }
1355*4d6fc14bSjoerg};
1356*4d6fc14bSjoerg
1357*4d6fc14bSjoergtemplate <class _Tp>
1358*4d6fc14bSjoergstruct __scalar_hash<_Tp, 3>
1359*4d6fc14bSjoerg    : public unary_function<_Tp, size_t>
1360*4d6fc14bSjoerg{
1361*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1362*4d6fc14bSjoerg    size_t operator()(_Tp __v) const _NOEXCEPT
1363*4d6fc14bSjoerg    {
1364*4d6fc14bSjoerg        union
1365*4d6fc14bSjoerg        {
1366*4d6fc14bSjoerg            _Tp __t;
1367*4d6fc14bSjoerg            struct
1368*4d6fc14bSjoerg            {
1369*4d6fc14bSjoerg                size_t __a;
1370*4d6fc14bSjoerg                size_t __b;
1371*4d6fc14bSjoerg                size_t __c;
1372*4d6fc14bSjoerg            } __s;
1373*4d6fc14bSjoerg        } __u;
1374*4d6fc14bSjoerg        __u.__t = __v;
1375*4d6fc14bSjoerg        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
1376*4d6fc14bSjoerg    }
1377*4d6fc14bSjoerg};
1378*4d6fc14bSjoerg
1379*4d6fc14bSjoergtemplate <class _Tp>
1380*4d6fc14bSjoergstruct __scalar_hash<_Tp, 4>
1381*4d6fc14bSjoerg    : public unary_function<_Tp, size_t>
1382*4d6fc14bSjoerg{
1383*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1384*4d6fc14bSjoerg    size_t operator()(_Tp __v) const _NOEXCEPT
1385*4d6fc14bSjoerg    {
1386*4d6fc14bSjoerg        union
1387*4d6fc14bSjoerg        {
1388*4d6fc14bSjoerg            _Tp __t;
1389*4d6fc14bSjoerg            struct
1390*4d6fc14bSjoerg            {
1391*4d6fc14bSjoerg                size_t __a;
1392*4d6fc14bSjoerg                size_t __b;
1393*4d6fc14bSjoerg                size_t __c;
1394*4d6fc14bSjoerg                size_t __d;
1395*4d6fc14bSjoerg            } __s;
1396*4d6fc14bSjoerg        } __u;
1397*4d6fc14bSjoerg        __u.__t = __v;
1398*4d6fc14bSjoerg        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
1399*4d6fc14bSjoerg    }
1400*4d6fc14bSjoerg};
1401*4d6fc14bSjoerg
1402*4d6fc14bSjoergstruct _PairT {
1403*4d6fc14bSjoerg  size_t first;
1404*4d6fc14bSjoerg  size_t second;
1405*4d6fc14bSjoerg};
1406*4d6fc14bSjoerg
1407*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY
1408*4d6fc14bSjoerginline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT {
1409*4d6fc14bSjoerg    typedef __scalar_hash<_PairT> _HashT;
1410*4d6fc14bSjoerg    const _PairT __p = {__lhs, __rhs};
1411*4d6fc14bSjoerg    return _HashT()(__p);
1412*4d6fc14bSjoerg}
1413*4d6fc14bSjoerg
1414*4d6fc14bSjoergtemplate<class _Tp>
1415*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<_Tp*>
1416*4d6fc14bSjoerg    : public unary_function<_Tp*, size_t>
1417*4d6fc14bSjoerg{
1418*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1419*4d6fc14bSjoerg    size_t operator()(_Tp* __v) const _NOEXCEPT
1420*4d6fc14bSjoerg    {
1421*4d6fc14bSjoerg        union
1422*4d6fc14bSjoerg        {
1423*4d6fc14bSjoerg            _Tp* __t;
1424*4d6fc14bSjoerg            size_t __a;
1425*4d6fc14bSjoerg        } __u;
1426*4d6fc14bSjoerg        __u.__t = __v;
1427*4d6fc14bSjoerg        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
1428*4d6fc14bSjoerg    }
1429*4d6fc14bSjoerg};
1430*4d6fc14bSjoerg
1431*4d6fc14bSjoerg
1432*4d6fc14bSjoergtemplate <>
1433*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<bool>
1434*4d6fc14bSjoerg    : public unary_function<bool, size_t>
1435*4d6fc14bSjoerg{
1436*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1437*4d6fc14bSjoerg    size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1438*4d6fc14bSjoerg};
1439*4d6fc14bSjoerg
1440*4d6fc14bSjoergtemplate <>
1441*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<char>
1442*4d6fc14bSjoerg    : public unary_function<char, size_t>
1443*4d6fc14bSjoerg{
1444*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1445*4d6fc14bSjoerg    size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1446*4d6fc14bSjoerg};
1447*4d6fc14bSjoerg
1448*4d6fc14bSjoergtemplate <>
1449*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<signed char>
1450*4d6fc14bSjoerg    : public unary_function<signed char, size_t>
1451*4d6fc14bSjoerg{
1452*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1453*4d6fc14bSjoerg    size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1454*4d6fc14bSjoerg};
1455*4d6fc14bSjoerg
1456*4d6fc14bSjoergtemplate <>
1457*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned char>
1458*4d6fc14bSjoerg    : public unary_function<unsigned char, size_t>
1459*4d6fc14bSjoerg{
1460*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1461*4d6fc14bSjoerg    size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1462*4d6fc14bSjoerg};
1463*4d6fc14bSjoerg
1464*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_CHAR8_T
1465*4d6fc14bSjoergtemplate <>
1466*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<char8_t>
1467*4d6fc14bSjoerg    : public unary_function<char8_t, size_t>
1468*4d6fc14bSjoerg{
1469*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1470*4d6fc14bSjoerg    size_t operator()(char8_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1471*4d6fc14bSjoerg};
1472*4d6fc14bSjoerg#endif // !_LIBCPP_HAS_NO_CHAR8_T
1473*4d6fc14bSjoerg
1474*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
1475*4d6fc14bSjoerg
1476*4d6fc14bSjoergtemplate <>
1477*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<char16_t>
1478*4d6fc14bSjoerg    : public unary_function<char16_t, size_t>
1479*4d6fc14bSjoerg{
1480*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1481*4d6fc14bSjoerg    size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1482*4d6fc14bSjoerg};
1483*4d6fc14bSjoerg
1484*4d6fc14bSjoergtemplate <>
1485*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<char32_t>
1486*4d6fc14bSjoerg    : public unary_function<char32_t, size_t>
1487*4d6fc14bSjoerg{
1488*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1489*4d6fc14bSjoerg    size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1490*4d6fc14bSjoerg};
1491*4d6fc14bSjoerg
1492*4d6fc14bSjoerg#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
1493*4d6fc14bSjoerg
1494*4d6fc14bSjoergtemplate <>
1495*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<wchar_t>
1496*4d6fc14bSjoerg    : public unary_function<wchar_t, size_t>
1497*4d6fc14bSjoerg{
1498*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1499*4d6fc14bSjoerg    size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1500*4d6fc14bSjoerg};
1501*4d6fc14bSjoerg
1502*4d6fc14bSjoergtemplate <>
1503*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<short>
1504*4d6fc14bSjoerg    : public unary_function<short, size_t>
1505*4d6fc14bSjoerg{
1506*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1507*4d6fc14bSjoerg    size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1508*4d6fc14bSjoerg};
1509*4d6fc14bSjoerg
1510*4d6fc14bSjoergtemplate <>
1511*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned short>
1512*4d6fc14bSjoerg    : public unary_function<unsigned short, size_t>
1513*4d6fc14bSjoerg{
1514*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1515*4d6fc14bSjoerg    size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1516*4d6fc14bSjoerg};
1517*4d6fc14bSjoerg
1518*4d6fc14bSjoergtemplate <>
1519*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<int>
1520*4d6fc14bSjoerg    : public unary_function<int, size_t>
1521*4d6fc14bSjoerg{
1522*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1523*4d6fc14bSjoerg    size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1524*4d6fc14bSjoerg};
1525*4d6fc14bSjoerg
1526*4d6fc14bSjoergtemplate <>
1527*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned int>
1528*4d6fc14bSjoerg    : public unary_function<unsigned int, size_t>
1529*4d6fc14bSjoerg{
1530*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1531*4d6fc14bSjoerg    size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1532*4d6fc14bSjoerg};
1533*4d6fc14bSjoerg
1534*4d6fc14bSjoergtemplate <>
1535*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<long>
1536*4d6fc14bSjoerg    : public unary_function<long, size_t>
1537*4d6fc14bSjoerg{
1538*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1539*4d6fc14bSjoerg    size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1540*4d6fc14bSjoerg};
1541*4d6fc14bSjoerg
1542*4d6fc14bSjoergtemplate <>
1543*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned long>
1544*4d6fc14bSjoerg    : public unary_function<unsigned long, size_t>
1545*4d6fc14bSjoerg{
1546*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1547*4d6fc14bSjoerg    size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1548*4d6fc14bSjoerg};
1549*4d6fc14bSjoerg
1550*4d6fc14bSjoergtemplate <>
1551*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<long long>
1552*4d6fc14bSjoerg    : public __scalar_hash<long long>
1553*4d6fc14bSjoerg{
1554*4d6fc14bSjoerg};
1555*4d6fc14bSjoerg
1556*4d6fc14bSjoergtemplate <>
1557*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned long long>
1558*4d6fc14bSjoerg    : public __scalar_hash<unsigned long long>
1559*4d6fc14bSjoerg{
1560*4d6fc14bSjoerg};
1561*4d6fc14bSjoerg
1562*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_INT128
1563*4d6fc14bSjoerg
1564*4d6fc14bSjoergtemplate <>
1565*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<__int128_t>
1566*4d6fc14bSjoerg    : public __scalar_hash<__int128_t>
1567*4d6fc14bSjoerg{
1568*4d6fc14bSjoerg};
1569*4d6fc14bSjoerg
1570*4d6fc14bSjoergtemplate <>
1571*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<__uint128_t>
1572*4d6fc14bSjoerg    : public __scalar_hash<__uint128_t>
1573*4d6fc14bSjoerg{
1574*4d6fc14bSjoerg};
1575*4d6fc14bSjoerg
1576*4d6fc14bSjoerg#endif
1577*4d6fc14bSjoerg
1578*4d6fc14bSjoergtemplate <>
1579*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<float>
1580*4d6fc14bSjoerg    : public __scalar_hash<float>
1581*4d6fc14bSjoerg{
1582*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1583*4d6fc14bSjoerg    size_t operator()(float __v) const _NOEXCEPT
1584*4d6fc14bSjoerg    {
1585*4d6fc14bSjoerg        // -0.0 and 0.0 should return same hash
1586*4d6fc14bSjoerg       if (__v == 0.0f)
1587*4d6fc14bSjoerg           return 0;
1588*4d6fc14bSjoerg        return __scalar_hash<float>::operator()(__v);
1589*4d6fc14bSjoerg    }
1590*4d6fc14bSjoerg};
1591*4d6fc14bSjoerg
1592*4d6fc14bSjoergtemplate <>
1593*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<double>
1594*4d6fc14bSjoerg    : public __scalar_hash<double>
1595*4d6fc14bSjoerg{
1596*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1597*4d6fc14bSjoerg    size_t operator()(double __v) const _NOEXCEPT
1598*4d6fc14bSjoerg    {
1599*4d6fc14bSjoerg        // -0.0 and 0.0 should return same hash
1600*4d6fc14bSjoerg       if (__v == 0.0)
1601*4d6fc14bSjoerg           return 0;
1602*4d6fc14bSjoerg        return __scalar_hash<double>::operator()(__v);
1603*4d6fc14bSjoerg    }
1604*4d6fc14bSjoerg};
1605*4d6fc14bSjoerg
1606*4d6fc14bSjoergtemplate <>
1607*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<long double>
1608*4d6fc14bSjoerg    : public __scalar_hash<long double>
1609*4d6fc14bSjoerg{
1610*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1611*4d6fc14bSjoerg    size_t operator()(long double __v) const _NOEXCEPT
1612*4d6fc14bSjoerg    {
1613*4d6fc14bSjoerg        // -0.0 and 0.0 should return same hash
1614*4d6fc14bSjoerg        if (__v == 0.0L)
1615*4d6fc14bSjoerg            return 0;
1616*4d6fc14bSjoerg#if defined(__i386__) || (defined(__x86_64__) && defined(__ILP32__))
1617*4d6fc14bSjoerg        // Zero out padding bits
1618*4d6fc14bSjoerg        union
1619*4d6fc14bSjoerg        {
1620*4d6fc14bSjoerg            long double __t;
1621*4d6fc14bSjoerg            struct
1622*4d6fc14bSjoerg            {
1623*4d6fc14bSjoerg                size_t __a;
1624*4d6fc14bSjoerg                size_t __b;
1625*4d6fc14bSjoerg                size_t __c;
1626*4d6fc14bSjoerg                size_t __d;
1627*4d6fc14bSjoerg            } __s;
1628*4d6fc14bSjoerg        } __u;
1629*4d6fc14bSjoerg        __u.__s.__a = 0;
1630*4d6fc14bSjoerg        __u.__s.__b = 0;
1631*4d6fc14bSjoerg        __u.__s.__c = 0;
1632*4d6fc14bSjoerg        __u.__s.__d = 0;
1633*4d6fc14bSjoerg        __u.__t = __v;
1634*4d6fc14bSjoerg        return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d;
1635*4d6fc14bSjoerg#elif defined(__x86_64__)
1636*4d6fc14bSjoerg        // Zero out padding bits
1637*4d6fc14bSjoerg        union
1638*4d6fc14bSjoerg        {
1639*4d6fc14bSjoerg            long double __t;
1640*4d6fc14bSjoerg            struct
1641*4d6fc14bSjoerg            {
1642*4d6fc14bSjoerg                size_t __a;
1643*4d6fc14bSjoerg                size_t __b;
1644*4d6fc14bSjoerg            } __s;
1645*4d6fc14bSjoerg        } __u;
1646*4d6fc14bSjoerg        __u.__s.__a = 0;
1647*4d6fc14bSjoerg        __u.__s.__b = 0;
1648*4d6fc14bSjoerg        __u.__t = __v;
1649*4d6fc14bSjoerg        return __u.__s.__a ^ __u.__s.__b;
1650*4d6fc14bSjoerg#else
1651*4d6fc14bSjoerg        return __scalar_hash<long double>::operator()(__v);
1652*4d6fc14bSjoerg#endif
1653*4d6fc14bSjoerg    }
1654*4d6fc14bSjoerg};
1655*4d6fc14bSjoerg
1656*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 11
1657*4d6fc14bSjoerg
1658*4d6fc14bSjoergtemplate <class _Tp, bool = is_enum<_Tp>::value>
1659*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS __enum_hash
1660*4d6fc14bSjoerg    : public unary_function<_Tp, size_t>
1661*4d6fc14bSjoerg{
1662*4d6fc14bSjoerg    _LIBCPP_INLINE_VISIBILITY
1663*4d6fc14bSjoerg    size_t operator()(_Tp __v) const _NOEXCEPT
1664*4d6fc14bSjoerg    {
1665*4d6fc14bSjoerg        typedef typename underlying_type<_Tp>::type type;
1666*4d6fc14bSjoerg        return hash<type>{}(static_cast<type>(__v));
1667*4d6fc14bSjoerg    }
1668*4d6fc14bSjoerg};
1669*4d6fc14bSjoergtemplate <class _Tp>
1670*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS __enum_hash<_Tp, false> {
1671*4d6fc14bSjoerg    __enum_hash() = delete;
1672*4d6fc14bSjoerg    __enum_hash(__enum_hash const&) = delete;
1673*4d6fc14bSjoerg    __enum_hash& operator=(__enum_hash const&) = delete;
1674*4d6fc14bSjoerg};
1675*4d6fc14bSjoerg
1676*4d6fc14bSjoergtemplate <class _Tp>
1677*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp>
1678*4d6fc14bSjoerg{
1679*4d6fc14bSjoerg};
1680*4d6fc14bSjoerg#endif
1681*4d6fc14bSjoerg
1682*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 14
1683*4d6fc14bSjoerg
1684*4d6fc14bSjoergtemplate <>
1685*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<nullptr_t>
1686*4d6fc14bSjoerg  : public unary_function<nullptr_t, size_t>
1687*4d6fc14bSjoerg{
1688*4d6fc14bSjoerg  _LIBCPP_INLINE_VISIBILITY
1689*4d6fc14bSjoerg  size_t operator()(nullptr_t) const _NOEXCEPT {
1690*4d6fc14bSjoerg    return 662607004ull;
1691*4d6fc14bSjoerg  }
1692*4d6fc14bSjoerg};
1693*4d6fc14bSjoerg#endif
1694*4d6fc14bSjoerg
1695*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG
1696*4d6fc14bSjoergtemplate <class _Key, class _Hash>
1697*4d6fc14bSjoergusing __check_hash_requirements _LIBCPP_NODEBUG_TYPE  = integral_constant<bool,
1698*4d6fc14bSjoerg    is_copy_constructible<_Hash>::value &&
1699*4d6fc14bSjoerg    is_move_constructible<_Hash>::value &&
1700*4d6fc14bSjoerg    __invokable_r<size_t, _Hash, _Key const&>::value
1701*4d6fc14bSjoerg>;
1702*4d6fc14bSjoerg
1703*4d6fc14bSjoergtemplate <class _Key, class _Hash = hash<_Key> >
1704*4d6fc14bSjoergusing __has_enabled_hash _LIBCPP_NODEBUG_TYPE = integral_constant<bool,
1705*4d6fc14bSjoerg    __check_hash_requirements<_Key, _Hash>::value &&
1706*4d6fc14bSjoerg    is_default_constructible<_Hash>::value
1707*4d6fc14bSjoerg>;
1708*4d6fc14bSjoerg
1709*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 14
1710*4d6fc14bSjoergtemplate <class _Type, class>
1711*4d6fc14bSjoergusing __enable_hash_helper_imp _LIBCPP_NODEBUG_TYPE  = _Type;
1712*4d6fc14bSjoerg
1713*4d6fc14bSjoergtemplate <class _Type, class ..._Keys>
1714*4d6fc14bSjoergusing __enable_hash_helper _LIBCPP_NODEBUG_TYPE  = __enable_hash_helper_imp<_Type,
1715*4d6fc14bSjoerg  typename enable_if<__all<__has_enabled_hash<_Keys>::value...>::value>::type
1716*4d6fc14bSjoerg>;
1717*4d6fc14bSjoerg#else
1718*4d6fc14bSjoergtemplate <class _Type, class ...>
1719*4d6fc14bSjoergusing __enable_hash_helper _LIBCPP_NODEBUG_TYPE = _Type;
1720*4d6fc14bSjoerg#endif
1721*4d6fc14bSjoerg
1722*4d6fc14bSjoerg#endif // !_LIBCPP_CXX03_LANG
1723*4d6fc14bSjoerg
1724*4d6fc14bSjoerg_LIBCPP_END_NAMESPACE_STD
1725*4d6fc14bSjoerg
1726*4d6fc14bSjoerg_LIBCPP_POP_MACROS
1727*4d6fc14bSjoerg
1728*4d6fc14bSjoerg#endif // _LIBCPP_UTILITY
1729