Cider Isn't Darwin Emulation, Really
Something went wrong. Try again.
47 kB · 1598 lines
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599// -*- C++ -*-//===-------------------------- utility -----------------------------------===////// The LLVM Compiler Infrastructure//// This file is dual licensed under the MIT and the University of Illinois Open// Source Licenses. See LICENSE.TXT for details.////===----------------------------------------------------------------------===//#ifndef _LIBCPP_UTILITY#define _LIBCPP_UTILITY/* utility synopsisnamespace std{template <class T> void swap(T& a, T& b);namespace rel_ops{ template<class T> bool operator!=(const T&, const T&); template<class T> bool operator> (const T&, const T&); template<class T> bool operator<=(const T&, const T&); template<class T> bool operator>=(const T&, const T&);}template<class T>voidswap(T& a, T& b) noexcept(is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value);template <class T, size_t N>voidswap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b)));template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept; // constexpr in C++14template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept; // constexpr in C++14template <class T> typename remove_reference<T>::type&& move(T&&) noexcept; // constexpr in C++14template <class T> typename conditional < !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value, const T&, T&& >::type move_if_noexcept(T& x) noexcept; // constexpr in C++14template <class T> constexpr add_const<T>_t& as_const(T& t) noexcept; // C++17template <class T> void as_const(const T&&) = delete; // C++17template <class T> typename add_rvalue_reference<T>::type declval() noexcept;template <class T1, class T2>struct pair{ typedef T1 first_type; typedef T2 second_type; T1 first; T2 second; pair(const pair&) = default; pair(pair&&) = default; constexpr pair(); pair(const T1& x, const T2& y); // constexpr in C++14 template <class U, class V> pair(U&& x, V&& y); // constexpr in C++14 template <class U, class V> pair(const pair<U, V>& p); // constexpr in C++14 template <class U, class V> pair(pair<U, V>&& p); // constexpr in C++14 template <class... Args1, class... Args2> pair(piecewise_construct_t, tuple<Args1...> first_args, tuple<Args2...> second_args); template <class U, class V> pair& operator=(const pair<U, V>& p); pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value && is_nothrow_move_assignable<T2>::value); template <class U, class V> pair& operator=(pair<U, V>&& p); void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> && is_nothrow_swappable_v<T2>);};template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&); // constexpr in C++14template <class T1, class T2>voidswap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));struct piecewise_construct_t { };constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();template <class T> class tuple_size;template <size_t I, class T> class tuple_element;template <class T1, class T2> struct tuple_size<pair<T1, T2> >;template <class T1, class T2> struct tuple_element<0, pair<T1, T2> >;template <class T1, class T2> struct tuple_element<1, pair<T1, T2> >;template<size_t I, class T1, class T2> typename tuple_element<I, pair<T1, T2> >::type& get(pair<T1, T2>&) noexcept; // constexpr in C++14template<size_t I, class T1, class T2> const typename tuple_element<I, pair<T1, T2> >::type& get(const pair<T1, T2>&) noexcept; // constexpr in C++14template<size_t I, class T1, class T2> typename tuple_element<I, pair<T1, T2> >::type&& get(pair<T1, T2>&&) noexcept; // constexpr in C++14template<size_t I, class T1, class T2> const typename tuple_element<I, pair<T1, T2> >::type&& get(const pair<T1, T2>&&) noexcept; // constexpr in C++14template<class T1, class T2> constexpr T1& get(pair<T1, T2>&) noexcept; // C++14template<class T1, class T2> constexpr const T1& get(const pair<T1, T2>&) noexcept; // C++14template<class T1, class T2> constexpr T1&& get(pair<T1, T2>&&) noexcept; // C++14template<class T1, class T2> constexpr const T1&& get(const pair<T1, T2>&&) noexcept; // C++14template<class T1, class T2> constexpr T1& get(pair<T2, T1>&) noexcept; // C++14template<class T1, class T2> constexpr const T1& get(const pair<T2, T1>&) noexcept; // C++14template<class T1, class T2> constexpr T1&& get(pair<T2, T1>&&) noexcept; // C++14template<class T1, class T2> constexpr const T1&& get(const pair<T2, T1>&&) noexcept; // C++14// C++14template<class T, T... I>struct integer_sequence{ typedef T value_type; static constexpr size_t size() noexcept;};template<size_t... I> using index_sequence = integer_sequence<size_t, I...>;template<class T, T N> using make_integer_sequence = integer_sequence<T, 0, 1, ..., N-1>;template<size_t N> using make_index_sequence = make_integer_sequence<size_t, N>;template<class... T> using index_sequence_for = make_index_sequence<sizeof...(T)>;template<class T, class U=T> T exchange(T& obj, U&& new_value);// 20.2.7, in-place construction // C++17struct in_place_t { explicit in_place_t() = default;};inline constexpr in_place_t in_place{};template <class T> struct in_place_type_t { explicit in_place_type_t() = default; };template <class T> inline constexpr in_place_type_t<T> in_place_type{};template <size_t I> struct in_place_index_t { explicit in_place_index_t() = default; };template <size_t I> inline constexpr in_place_index_t<I> in_place_index{};} // std*/#include <__config>#include <__tuple>#include <type_traits>#include <initializer_list>#include <cstddef>#include <cstring>#include <cstdint>#include <__debug>#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)#pragma GCC system_header#endif_LIBCPP_BEGIN_NAMESPACE_STDnamespace rel_ops{template<class _Tp>inline _LIBCPP_INLINE_VISIBILITYbooloperator!=(const _Tp& __x, const _Tp& __y){ return !(__x == __y);}template<class _Tp>inline _LIBCPP_INLINE_VISIBILITYbooloperator> (const _Tp& __x, const _Tp& __y){ return __y < __x;}template<class _Tp>inline _LIBCPP_INLINE_VISIBILITYbooloperator<=(const _Tp& __x, const _Tp& __y){ return !(__y < __x);}template<class _Tp>inline _LIBCPP_INLINE_VISIBILITYbooloperator>=(const _Tp& __x, const _Tp& __y){ return !(__x < __y);}} // rel_ops// swap_rangestemplate <class _ForwardIterator1, class _ForwardIterator2>inline _LIBCPP_INLINE_VISIBILITY_ForwardIterator2swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2){ for(; __first1 != __last1; ++__first1, (void) ++__first2) swap(*__first1, *__first2); return __first2;}// forward declared in <type_traits>template<class _Tp, size_t _Np>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_swappable<_Tp>::value>::typeswap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value){ _VSTD::swap_ranges(__a, __a + _Np, __b);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11#ifndef _LIBCPP_CXX03_LANGtypename conditional< !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&, _Tp&&>::type#else // _LIBCPP_CXX03_LANGconst _Tp&#endifmove_if_noexcept(_Tp& __x) _NOEXCEPT{ return _VSTD::move(__x);}#if _LIBCPP_STD_VER > 14template <class _Tp> constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }template <class _Tp> void as_const(const _Tp&&) = delete;#endifstruct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { };#if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_UTILITY)extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();#elseconstexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();#endif#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)struct __non_trivially_copyable_base { _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY __non_trivially_copyable_base() _NOEXCEPT {} _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY __non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}};#endiftemplate <class _T1, class _T2>struct _LIBCPP_TEMPLATE_VIS pair#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR): private __non_trivially_copyable_base#endif{ typedef _T1 first_type; typedef _T2 second_type; _T1 first; _T2 second;#if !defined(_LIBCPP_CXX03_LANG) pair(pair const&) = default; pair(pair&&) = default;#else // Use the implicitly declared copy constructor in C++03#endif#ifdef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY pair() : first(), second() {} _LIBCPP_INLINE_VISIBILITY pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {} template <class _U1, class _U2> _LIBCPP_INLINE_VISIBILITY pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {} _LIBCPP_INLINE_VISIBILITY pair& operator=(pair const& __p) { first = __p.first; second = __p.second; return *this; }#else template <bool _Val> using _EnableB = typename enable_if<_Val, bool>::type; struct _CheckArgs { template <class _U1, class _U2> static constexpr bool __enable_default() { return is_default_constructible<_U1>::value && is_default_constructible<_U2>::value; } template <class _U1, class _U2> static constexpr bool __enable_explicit() { return is_constructible<first_type, _U1>::value && is_constructible<second_type, _U2>::value && (!is_convertible<_U1, first_type>::value || !is_convertible<_U2, second_type>::value); } template <class _U1, class _U2> static constexpr bool __enable_implicit() { return is_constructible<first_type, _U1>::value && is_constructible<second_type, _U2>::value && is_convertible<_U1, first_type>::value && is_convertible<_U2, second_type>::value; } }; template <bool _MaybeEnable> using _CheckArgsDep = typename conditional< _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type; struct _CheckTupleLikeConstructor { template <class _Tuple> static constexpr bool __enable_implicit() { return __tuple_convertible<_Tuple, pair>::value; } template <class _Tuple> static constexpr bool __enable_explicit() { return __tuple_constructible<_Tuple, pair>::value && !__tuple_convertible<_Tuple, pair>::value; } template <class _Tuple> static constexpr bool __enable_assign() { return __tuple_assignable<_Tuple, pair>::value; } }; template <class _Tuple> using _CheckTLC = typename conditional< __tuple_like_with_size<_Tuple, 2>::value && !is_same<typename decay<_Tuple>::type, pair>::value, _CheckTupleLikeConstructor, __check_tuple_constructor_fail >::type; template<bool _Dummy = true, _EnableB< _CheckArgsDep<_Dummy>::template __enable_default<_T1, _T2>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR pair() : first(), second() {} template <bool _Dummy = true, _EnableB< _CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {} template<bool _Dummy = true, _EnableB< _CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {} template<class _U1, class _U2, _EnableB< _CheckArgs::template __enable_explicit<_U1, _U2>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit pair(_U1&& __u1, _U2&& __u2) : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} template<class _U1, class _U2, _EnableB< _CheckArgs::template __enable_implicit<_U1, _U2>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 pair(_U1&& __u1, _U2&& __u2) : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} template<class _U1, class _U2, _EnableB< _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit pair(pair<_U1, _U2> const& __p) : first(__p.first), second(__p.second) {} template<class _U1, class _U2, _EnableB< _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 pair(pair<_U1, _U2> const& __p) : first(__p.first), second(__p.second) {} template<class _U1, class _U2, _EnableB< _CheckArgs::template __enable_explicit<_U1, _U2>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit pair(pair<_U1, _U2>&&__p) : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} template<class _U1, class _U2, _EnableB< _CheckArgs::template __enable_implicit<_U1, _U2>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 pair(pair<_U1, _U2>&& __p) : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} template<class _Tuple, _EnableB< _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit pair(_Tuple&& __p) : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))), second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {} template<class _Tuple, _EnableB< _CheckTLC<_Tuple>::template __enable_implicit<_Tuple>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 pair(_Tuple&& __p) : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))), second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {} template <class... _Args1, class... _Args2> _LIBCPP_INLINE_VISIBILITY pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, tuple<_Args2...> __second_args) : pair(__pc, __first_args, __second_args, typename __make_tuple_indices<sizeof...(_Args1)>::type(), typename __make_tuple_indices<sizeof...(_Args2) >::type()) {} _LIBCPP_INLINE_VISIBILITY pair& operator=(typename conditional< is_copy_assignable<first_type>::value && is_copy_assignable<second_type>::value, pair, __nat>::type const& __p) _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value && is_nothrow_copy_assignable<second_type>::value) { first = __p.first; second = __p.second; return *this; } _LIBCPP_INLINE_VISIBILITY pair& operator=(typename conditional< is_move_assignable<first_type>::value && is_move_assignable<second_type>::value, pair, __nat>::type&& __p) _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value && is_nothrow_move_assignable<second_type>::value) { first = _VSTD::forward<first_type>(__p.first); second = _VSTD::forward<second_type>(__p.second); return *this; } template <class _Tuple, _EnableB< _CheckTLC<_Tuple>::template __enable_assign<_Tuple>() > = false> _LIBCPP_INLINE_VISIBILITY pair& operator=(_Tuple&& __p) { first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p)); second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p)); return *this; }#endif _LIBCPP_INLINE_VISIBILITY void swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value && __is_nothrow_swappable<second_type>::value) { using _VSTD::swap; swap(first, __p.first); swap(second, __p.second); }private:#ifndef _LIBCPP_CXX03_LANG template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> _LIBCPP_INLINE_VISIBILITY pair(piecewise_construct_t, tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, __tuple_indices<_I1...>, __tuple_indices<_I2...>);#endif};template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11booloperator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y){ return __x.first == __y.first && __x.second == __y.second;}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11booloperator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y){ return !(__x == __y);}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11booloperator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y){ return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11booloperator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y){ return __y < __x;}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11booloperator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y){ return !(__x < __y);}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11booloperator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y){ return !(__y < __x);}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYtypename enable_if< __is_swappable<_T1>::value && __is_swappable<_T2>::value, void>::typeswap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) _NOEXCEPT_((__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value)){ __x.swap(__y);}#ifndef _LIBCPP_CXX03_LANGtemplate <class _Tp>struct __make_pair_return_impl{ typedef _Tp type;};template <class _Tp>struct __make_pair_return_impl<reference_wrapper<_Tp>>{ typedef _Tp& type;};template <class _Tp>struct __make_pair_return{ typedef typename __make_pair_return_impl<typename decay<_Tp>::type>::type type;};template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>make_pair(_T1&& __t1, _T2&& __t2){ return pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type> (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));}#else // _LIBCPP_CXX03_LANGtemplate <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYpair<_T1,_T2>make_pair(_T1 __x, _T2 __y){ return pair<_T1, _T2>(__x, __y);}#endif // _LIBCPP_CXX03_LANGtemplate <class _T1, class _T2> class _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> > : public integral_constant<size_t, 2> {};template <size_t _Ip, class _T1, class _T2>class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >{ static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");};template <class _T1, class _T2>class _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >{public: typedef _T1 type;};template <class _T1, class _T2>class _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >{public: typedef _T2 type;};template <size_t _Ip> struct __get_pair;template <>struct __get_pair<0>{ template <class _T1, class _T2> static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;} template <class _T1, class _T2> static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _T1& get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}#ifndef _LIBCPP_CXX03_LANG template <class _T1, class _T2> static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);} template <class _T1, class _T2> static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _T1&& get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);}#endif // _LIBCPP_CXX03_LANG};template <>struct __get_pair<1>{ template <class _T1, class _T2> static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _T2& get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;} template <class _T1, class _T2> static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _T2& get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}#ifndef _LIBCPP_CXX03_LANG template <class _T1, class _T2> static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _T2&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);} template <class _T1, class _T2> static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _T2&& get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);}#endif // _LIBCPP_CXX03_LANG};template <size_t _Ip, class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11typename tuple_element<_Ip, pair<_T1, _T2> >::type&get(pair<_T1, _T2>& __p) _NOEXCEPT{ return __get_pair<_Ip>::get(__p);}template <size_t _Ip, class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const typename tuple_element<_Ip, pair<_T1, _T2> >::type&get(const pair<_T1, _T2>& __p) _NOEXCEPT{ return __get_pair<_Ip>::get(__p);}#ifndef _LIBCPP_CXX03_LANGtemplate <size_t _Ip, class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11typename tuple_element<_Ip, pair<_T1, _T2> >::type&&get(pair<_T1, _T2>&& __p) _NOEXCEPT{ return __get_pair<_Ip>::get(_VSTD::move(__p));}template <size_t _Ip, class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&get(const pair<_T1, _T2>&& __p) _NOEXCEPT{ return __get_pair<_Ip>::get(_VSTD::move(__p));}#endif // _LIBCPP_CXX03_LANG#if _LIBCPP_STD_VER > 11template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYconstexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT{ return __get_pair<0>::get(__p);}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYconstexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT{ return __get_pair<0>::get(__p);}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYconstexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT{ return __get_pair<0>::get(_VSTD::move(__p));}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYconstexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT{ return __get_pair<0>::get(_VSTD::move(__p));}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYconstexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT{ return __get_pair<1>::get(__p);}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYconstexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT{ return __get_pair<1>::get(__p);}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYconstexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT{ return __get_pair<1>::get(_VSTD::move(__p));}template <class _T1, class _T2>inline _LIBCPP_INLINE_VISIBILITYconstexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT{ return __get_pair<1>::get(_VSTD::move(__p));}#endif#if _LIBCPP_STD_VER > 11template<class _Tp, _Tp... _Ip>struct _LIBCPP_TEMPLATE_VIS integer_sequence{ typedef _Tp value_type; static_assert( is_integral<_Tp>::value, "std::integer_sequence can only be instantiated with an integral type" ); static _LIBCPP_INLINE_VISIBILITY constexpr size_t size() noexcept { return sizeof...(_Ip); }};template<size_t... _Ip> using index_sequence = integer_sequence<size_t, _Ip...>;#if __has_builtin(__make_integer_seq) && !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)template <class _Tp, _Tp _Ep>using __make_integer_sequence = __make_integer_seq<integer_sequence, _Tp, _Ep>;#elsetemplate<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked = typename __detail::__make<_Np>::type::template __convert<integer_sequence, _Tp>;template <class _Tp, _Tp _Ep>struct __make_integer_sequence_checked{ static_assert(is_integral<_Tp>::value, "std::make_integer_sequence can only be instantiated with an integral type" ); static_assert(0 <= _Ep, "std::make_integer_sequence must have a non-negative sequence length"); // Workaround GCC bug by preventing bad installations when 0 <= _Ep // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68929 typedef __make_integer_sequence_unchecked<_Tp, 0 <= _Ep ? _Ep : 0> type;};template <class _Tp, _Tp _Ep>using __make_integer_sequence = typename __make_integer_sequence_checked<_Tp, _Ep>::type;#endiftemplate<class _Tp, _Tp _Np> using make_integer_sequence = __make_integer_sequence<_Tp, _Np>;template<size_t _Np> using make_index_sequence = make_integer_sequence<size_t, _Np>;template<class... _Tp> using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;#endif // _LIBCPP_STD_VER > 11#if _LIBCPP_STD_VER > 11template<class _T1, class _T2 = _T1>inline _LIBCPP_INLINE_VISIBILITY_T1 exchange(_T1& __obj, _T2 && __new_value){ _T1 __old_value = _VSTD::move(__obj); __obj = _VSTD::forward<_T2>(__new_value); return __old_value;}#endif // _LIBCPP_STD_VER > 11#if _LIBCPP_STD_VER > 14struct _LIBCPP_TYPE_VIS in_place_t { explicit in_place_t() = default;};#ifndef _LIBCPP_HAS_NO_INLINE_VARIABLESinline#endifconstexpr in_place_t in_place{};template <class _Tp>struct _LIBCPP_TEMPLATE_VIS in_place_type_t { explicit in_place_type_t() = default;};template <class _Tp>#ifndef _LIBCPP_HAS_NO_INLINE_VARIABLESinline#endifconstexpr in_place_type_t<_Tp> in_place_type{};template <size_t _Idx>struct _LIBCPP_TYPE_VIS in_place_index_t { explicit in_place_index_t() = default;};template <size_t _Idx>#ifndef _LIBCPP_HAS_NO_INLINE_VARIABLESinline#endifconstexpr in_place_index_t<_Idx> in_place_index{};template <class _Tp> struct __is_inplace_type_imp : false_type {};template <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {};template <class _Tp>using __is_inplace_type = __is_inplace_type_imp<__uncvref_t<_Tp>>;template <class _Tp> struct __is_inplace_index_imp : false_type {};template <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {};template <class _Tp>using __is_inplace_index = __is_inplace_index_imp<__uncvref_t<_Tp>>;#endif // _LIBCPP_STD_VER > 14template <class _Arg, class _Result>struct _LIBCPP_TEMPLATE_VIS unary_function{ typedef _Arg argument_type; typedef _Result result_type;};template <class _Size>inline _LIBCPP_INLINE_VISIBILITY_Size__loadword(const void* __p){ _Size __r; std::memcpy(&__r, __p, sizeof(__r)); return __r;}// We use murmur2 when size_t is 32 bits, and cityhash64 when size_t// is 64 bits. This is because cityhash64 uses 64bit x 64bit// multiplication, which can be very slow on 32-bit systems.template <class _Size, size_t = sizeof(_Size)*__CHAR_BIT__>struct __murmur2_or_cityhash;template <class _Size>struct __murmur2_or_cityhash<_Size, 32>{ inline _Size operator()(const void* __key, _Size __len) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK;};// murmur2template <class _Size>_Size__murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len){ const _Size __m = 0x5bd1e995; const _Size __r = 24; _Size __h = __len; const unsigned char* __data = static_cast<const unsigned char*>(__key); for (; __len >= 4; __data += 4, __len -= 4) { _Size __k = __loadword<_Size>(__data); __k *= __m; __k ^= __k >> __r; __k *= __m; __h *= __m; __h ^= __k; } switch (__len) { case 3: __h ^= __data[2] << 16; case 2: __h ^= __data[1] << 8; case 1: __h ^= __data[0]; __h *= __m; } __h ^= __h >> 13; __h *= __m; __h ^= __h >> 15; return __h;}template <class _Size>struct __murmur2_or_cityhash<_Size, 64>{ inline _Size operator()(const void* __key, _Size __len) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK; private: // Some primes between 2^63 and 2^64. static const _Size __k0 = 0xc3a5c85c97cb3127ULL; static const _Size __k1 = 0xb492b66fbe98f273ULL; static const _Size __k2 = 0x9ae16a3b2f90404fULL; static const _Size __k3 = 0xc949d7c7509e6557ULL; static _Size __rotate(_Size __val, int __shift) { return __shift == 0 ? __val : ((__val >> __shift) | (__val << (64 - __shift))); } static _Size __rotate_by_at_least_1(_Size __val, int __shift) { return (__val >> __shift) | (__val << (64 - __shift)); } static _Size __shift_mix(_Size __val) { return __val ^ (__val >> 47); } static _Size __hash_len_16(_Size __u, _Size __v) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { const _Size __mul = 0x9ddfea08eb382d69ULL; _Size __a = (__u ^ __v) * __mul; __a ^= (__a >> 47); _Size __b = (__v ^ __a) * __mul; __b ^= (__b >> 47); __b *= __mul; return __b; } static _Size __hash_len_0_to_16(const char* __s, _Size __len) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { if (__len > 8) { const _Size __a = __loadword<_Size>(__s); const _Size __b = __loadword<_Size>(__s + __len - 8); return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b; } if (__len >= 4) { const uint32_t __a = __loadword<uint32_t>(__s); const uint32_t __b = __loadword<uint32_t>(__s + __len - 4); return __hash_len_16(__len + (__a << 3), __b); } if (__len > 0) { const unsigned char __a = __s[0]; const unsigned char __b = __s[__len >> 1]; const unsigned char __c = __s[__len - 1]; const uint32_t __y = static_cast<uint32_t>(__a) + (static_cast<uint32_t>(__b) << 8); const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2); return __shift_mix(__y * __k2 ^ __z * __k3) * __k2; } return __k2; } static _Size __hash_len_17_to_32(const char *__s, _Size __len) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { const _Size __a = __loadword<_Size>(__s) * __k1; const _Size __b = __loadword<_Size>(__s + 8); const _Size __c = __loadword<_Size>(__s + __len - 8) * __k2; const _Size __d = __loadword<_Size>(__s + __len - 16) * __k0; return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d, __a + __rotate(__b ^ __k3, 20) - __c + __len); } // Return a 16-byte hash for 48 bytes. Quick and dirty. // Callers do best to use "random-looking" values for a and b. static pair<_Size, _Size> __weak_hash_len_32_with_seeds( _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { __a += __w; __b = __rotate(__b + __a + __z, 21); const _Size __c = __a; __a += __x; __a += __y; __b += __rotate(__a, 44); return pair<_Size, _Size>(__a + __z, __b + __c); } // Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty. static pair<_Size, _Size> __weak_hash_len_32_with_seeds( const char* __s, _Size __a, _Size __b) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { return __weak_hash_len_32_with_seeds(__loadword<_Size>(__s), __loadword<_Size>(__s + 8), __loadword<_Size>(__s + 16), __loadword<_Size>(__s + 24), __a, __b); } // Return an 8-byte hash for 33 to 64 bytes. static _Size __hash_len_33_to_64(const char *__s, size_t __len) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { _Size __z = __loadword<_Size>(__s + 24); _Size __a = __loadword<_Size>(__s) + (__len + __loadword<_Size>(__s + __len - 16)) * __k0; _Size __b = __rotate(__a + __z, 52); _Size __c = __rotate(__a, 37); __a += __loadword<_Size>(__s + 8); __c += __rotate(__a, 7); __a += __loadword<_Size>(__s + 16); _Size __vf = __a + __z; _Size __vs = __b + __rotate(__a, 31) + __c; __a = __loadword<_Size>(__s + 16) + __loadword<_Size>(__s + __len - 32); __z += __loadword<_Size>(__s + __len - 8); __b = __rotate(__a + __z, 52); __c = __rotate(__a, 37); __a += __loadword<_Size>(__s + __len - 24); __c += __rotate(__a, 7); __a += __loadword<_Size>(__s + __len - 16); _Size __wf = __a + __z; _Size __ws = __b + __rotate(__a, 31) + __c; _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0); return __shift_mix(__r * __k0 + __vs) * __k2; }};// cityhash64template <class _Size>_Size__murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len){ const char* __s = static_cast<const char*>(__key); if (__len <= 32) { if (__len <= 16) { return __hash_len_0_to_16(__s, __len); } else { return __hash_len_17_to_32(__s, __len); } } else if (__len <= 64) { return __hash_len_33_to_64(__s, __len); } // For strings over 64 bytes we hash the end first, and then as we // loop we keep 56 bytes of state: v, w, x, y, and z. _Size __x = __loadword<_Size>(__s + __len - 40); _Size __y = __loadword<_Size>(__s + __len - 16) + __loadword<_Size>(__s + __len - 56); _Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len, __loadword<_Size>(__s + __len - 24)); pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z); pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x); __x = __x * __k1 + __loadword<_Size>(__s); // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks. __len = (__len - 1) & ~static_cast<_Size>(63); do { __x = __rotate(__x + __y + __v.first + __loadword<_Size>(__s + 8), 37) * __k1; __y = __rotate(__y + __v.second + __loadword<_Size>(__s + 48), 42) * __k1; __x ^= __w.second; __y += __v.first + __loadword<_Size>(__s + 40); __z = __rotate(__z + __w.first, 33) * __k1; __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first); __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second, __y + __loadword<_Size>(__s + 16)); std::swap(__z, __x); __s += 64; __len -= 64; } while (__len != 0); return __hash_len_16( __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z, __hash_len_16(__v.second, __w.second) + __x);}template <class _Tp, size_t = sizeof(_Tp) / sizeof(size_t)>struct __scalar_hash;template <class _Tp>struct __scalar_hash<_Tp, 0> : public unary_function<_Tp, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(_Tp __v) const _NOEXCEPT { union { _Tp __t; size_t __a; } __u; __u.__a = 0; __u.__t = __v; return __u.__a; }};template <class _Tp>struct __scalar_hash<_Tp, 1> : public unary_function<_Tp, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(_Tp __v) const _NOEXCEPT { union { _Tp __t; size_t __a; } __u; __u.__t = __v; return __u.__a; }};template <class _Tp>struct __scalar_hash<_Tp, 2> : public unary_function<_Tp, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(_Tp __v) const _NOEXCEPT { union { _Tp __t; struct { size_t __a; size_t __b; } __s; } __u; __u.__t = __v; return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); }};template <class _Tp>struct __scalar_hash<_Tp, 3> : public unary_function<_Tp, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(_Tp __v) const _NOEXCEPT { union { _Tp __t; struct { size_t __a; size_t __b; size_t __c; } __s; } __u; __u.__t = __v; return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); }};template <class _Tp>struct __scalar_hash<_Tp, 4> : public unary_function<_Tp, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(_Tp __v) const _NOEXCEPT { union { _Tp __t; struct { size_t __a; size_t __b; size_t __c; size_t __d; } __s; } __u; __u.__t = __v; return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); }};struct _PairT { size_t first; size_t second;};_LIBCPP_INLINE_VISIBILITYinline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT { typedef __scalar_hash<_PairT> _HashT; const _PairT __p = {__lhs, __rhs}; return _HashT()(__p);}template<class _Tp>struct _LIBCPP_TEMPLATE_VIS hash<_Tp*> : public unary_function<_Tp*, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(_Tp* __v) const _NOEXCEPT { union { _Tp* __t; size_t __a; } __u; __u.__t = __v; return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); }};template <>struct _LIBCPP_TEMPLATE_VIS hash<bool> : public unary_function<bool, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<char> : public unary_function<char, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<signed char> : public unary_function<signed char, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<unsigned char> : public unary_function<unsigned char, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};#ifndef _LIBCPP_HAS_NO_UNICODE_CHARStemplate <>struct _LIBCPP_TEMPLATE_VIS hash<char16_t> : public unary_function<char16_t, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<char32_t> : public unary_function<char32_t, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};#endif // _LIBCPP_HAS_NO_UNICODE_CHARStemplate <>struct _LIBCPP_TEMPLATE_VIS hash<wchar_t> : public unary_function<wchar_t, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<short> : public unary_function<short, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<unsigned short> : public unary_function<unsigned short, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<int> : public unary_function<int, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<unsigned int> : public unary_function<unsigned int, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<long> : public unary_function<long, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<unsigned long> : public unary_function<unsigned long, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}};template <>struct _LIBCPP_TEMPLATE_VIS hash<long long> : public __scalar_hash<long long>{};template <>struct _LIBCPP_TEMPLATE_VIS hash<unsigned long long> : public __scalar_hash<unsigned long long>{};#ifndef _LIBCPP_HAS_NO_INT128template <>struct _LIBCPP_TEMPLATE_VIS hash<__int128_t> : public __scalar_hash<__int128_t>{};template <>struct _LIBCPP_TEMPLATE_VIS hash<__uint128_t> : public __scalar_hash<__uint128_t>{};#endiftemplate <>struct _LIBCPP_TEMPLATE_VIS hash<float> : public __scalar_hash<float>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(float __v) const _NOEXCEPT { // -0.0 and 0.0 should return same hash if (__v == 0) return 0; return __scalar_hash<float>::operator()(__v); }};template <>struct _LIBCPP_TEMPLATE_VIS hash<double> : public __scalar_hash<double>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(double __v) const _NOEXCEPT { // -0.0 and 0.0 should return same hash if (__v == 0) return 0; return __scalar_hash<double>::operator()(__v); }};template <>struct _LIBCPP_TEMPLATE_VIS hash<long double> : public __scalar_hash<long double>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(long double __v) const _NOEXCEPT { // -0.0 and 0.0 should return same hash if (__v == 0) return 0;#if defined(__i386__) // Zero out padding bits union { long double __t; struct { size_t __a; size_t __b; size_t __c; size_t __d; } __s; } __u; __u.__s.__a = 0; __u.__s.__b = 0; __u.__s.__c = 0; __u.__s.__d = 0; __u.__t = __v; return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d;#elif defined(__x86_64__) // Zero out padding bits union { long double __t; struct { size_t __a; size_t __b; } __s; } __u; __u.__s.__a = 0; __u.__s.__b = 0; __u.__t = __v; return __u.__s.__a ^ __u.__s.__b;#else return __scalar_hash<long double>::operator()(__v);#endif }};#if _LIBCPP_STD_VER > 11template <class _Tp, bool = is_enum<_Tp>::value>struct _LIBCPP_TEMPLATE_VIS __enum_hash : public unary_function<_Tp, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(_Tp __v) const _NOEXCEPT { typedef typename underlying_type<_Tp>::type type; return hash<type>{}(static_cast<type>(__v)); }};template <class _Tp>struct _LIBCPP_TEMPLATE_VIS __enum_hash<_Tp, false> { __enum_hash() = delete; __enum_hash(__enum_hash const&) = delete; __enum_hash& operator=(__enum_hash const&) = delete;};template <class _Tp>struct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp>{};#endif#if _LIBCPP_STD_VER > 14template <>struct _LIBCPP_TEMPLATE_VIS hash<nullptr_t> : public unary_function<nullptr_t, size_t>{ _LIBCPP_INLINE_VISIBILITY size_t operator()(nullptr_t) const _NOEXCEPT { return 662607004ull; }};#endif#ifndef _LIBCPP_CXX03_LANGtemplate <class _Key, class _Hash>using __check_hash_requirements = integral_constant<bool, is_copy_constructible<_Hash>::value && is_move_constructible<_Hash>::value && __invokable_r<size_t, _Hash, _Key const&>::value>;template <class _Key, class _Hash = std::hash<_Key> >using __has_enabled_hash = integral_constant<bool, __check_hash_requirements<_Key, _Hash>::value && is_default_constructible<_Hash>::value>;#if _LIBCPP_STD_VER > 14template <class _Type, class>using __enable_hash_helper_imp = _Type;template <class _Type, class ..._Keys>using __enable_hash_helper = __enable_hash_helper_imp<_Type, typename enable_if<__all<__has_enabled_hash<_Keys>::value...>::value>::type>;#elsetemplate <class _Type, class ...>using __enable_hash_helper = _Type;#endif#endif // !_LIBCPP_CXX03_LANG_LIBCPP_END_NAMESPACE_STD#endif // _LIBCPP_UTILITY